Add prefetch partitions functional test (#1089)

Functional tests to check api compatibility.
Update url generator to work with mock server.

Relates-To: OLPEDGE-2343

Signed-off-by: Liubov Didkivska <[email protected]>

Author: Liubov Didkivska

tests/common/ApiDefaultResponses.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2020 HERE Europe B.V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * License-Filename: LICENSE
+ */
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <olp/core/client/model/Api.h>
+#include "ApiDefaultResponses.h"
+
+namespace mockserver {
+
+const std::vector<std::pair<std::string, std::string>>
+    ApiDefaultResponses::kResourceApis = {
+        {"blob", "v1"},         {"index", "v1"},        {"ingest", "v1"},
+        {"metadata", "v1"},     {"notification", "v2"}, {"publish", "v2"},
+        {"query", "v1"},        {"statistics", "v1"},   {"stream", "v2"},
+        {"volatile-blob", "v1"}};
+const std::vector<std::pair<std::string, std::string>>
+    ApiDefaultResponses::kPlatformApis = {{"account", "v1"},
+                                          {"artifact", "v1"},
+                                          {"authentication", "v1"},
+                                          {"authorization", "v1"},
+                                          {"config", "v1"},
+                                          {"consent", "v1"},
+                                          {"location-service-registry", "v1"},
+                                          {"lookup", "v1"},
+                                          {"marketplace", "v2"},
+                                          {"pipelines", "v2"}};
+
+olp::client::Apis ApiDefaultResponses::GenerateResourceApisResponse(
+    std::string catalog) {
+  return GenerateApisResponse(kResourceApis, catalog);
+}
+
+olp::client::Apis ApiDefaultResponses::GeneratePlatformApisResponse() {
+  return GenerateApisResponse(kPlatformApis);
+}
+
+olp::client::Apis ApiDefaultResponses::GenerateApisResponse(
+    std::vector<std::pair<std::string, std::string>> api_types,
+    std::string catalog) {
+  olp::client::Apis apis(api_types.size());
+  if (!catalog.empty()) {
+    catalog.insert(0, "/catalogs/");
+  }
+  for (size_t i = 0; i < apis.size(); i++) {
+    apis[i].SetApi(api_types.at(i).first);
+    apis[i].SetBaseUrl("https://tmp." + api_types.at(i).first +
+                       ".data.api.platform.here.com/" + api_types.at(i).first +
+                       "/" + api_types.at(i).second + catalog);
+    apis[i].SetVersion(api_types.at(i).second);
+  }
+  return apis;
+}
+
+}  // namespace mockserver

tests/common/ApiDefaultResponses.h

@@ -29,52 +29,16 @@ namespace mockserver {
 
 class ApiDefaultResponses {
  public:
-  static olp::client::Apis GenerateResourceApisResponse(
-      std::string catalog) {
-    return GenerateApisResponse({{"blob", "v1"},
-                                 {"index", "v1"},
-                                 {"ingest", "v1"},
-                                 {"metadata", "v1"},
-                                 {"notification", "v2"},
-                                 {"publish", "v2"},
-                                 {"query", "v1"},
-                                 {"statistics", "v1"},
-                                 {"stream", "v2"},
-                                 {"volatile-blob", "v1"}},
-                                catalog);
-  }
+  static olp::client::Apis GenerateResourceApisResponse(std::string catalog);
 
-  static olp::client::Apis GeneratePlatformApisResponse() {
-    return GenerateApisResponse({{"account", "v1"},
-                                 {"artifact", "v1"},
-                                 {"authentication", "v1"},
-                                 {"authorization", "v1"},
-                                 {"config", "v1"},
-                                 {"consent", "v1"},
-                                 {"location-service-registry", "v1"},
-                                 {"lookup", "v1"},
-                                 {"marketplace", "v2"},
-                                 {"pipelines", "v2"}});
-  }
+  static olp::client::Apis GeneratePlatformApisResponse();
 
   static olp::client::Apis GenerateApisResponse(
       std::vector<std::pair<std::string, std::string>> api_types,
-      std::string catalog = "") {
-    olp::client::Apis apis(api_types.size());
-    std::string version = "v1";
-    if (!catalog.empty()) {
-      catalog.insert(0, "/catalogs/");
-    }
-    for (size_t i = 0; i < apis.size(); i++) {
-      apis[i].SetApi(api_types.at(i).first);
-      apis[i].SetBaseUrl("https://tmp." + api_types.at(i).first +
-                         ".data.api.platform.here.com/" +
-                         api_types.at(i).first + "/" + api_types.at(i).second +
-                         catalog);
-      apis[i].SetVersion(api_types.at(i).second);
-    }
-    return apis;
-  }
+      std::string catalog = "");
+
+  static const std::vector<std::pair<std::string, std::string>> kResourceApis;
+  static const std::vector<std::pair<std::string, std::string>> kPlatformApis;
 };
 
 }  // namespace mockserver

tests/common/CMakeLists.txt

@@ -29,6 +29,7 @@ set(OLP_SDK_TESTS_COMMON_HEADERS
 set(OLP_SDK_TESTS_COMMON_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/mocks/CacheMock.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mocks/NetworkMock.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ApiDefaultResponses.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ReadDefaultResponses.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/PlatformUrlsGenerator.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ResponseGenerator.cpp

tests/common/PlatformUrlsGenerator.cpp

@@ -19,16 +19,19 @@
 
 #include "PlatformUrlsGenerator.h"
 
+#include <utility>
+
 #include <olp/dataservice/read/model/Partitions.h>
 #include <olp/dataservice/read/model/VersionResponse.h>
+#include "ApiDefaultResponses.h"
 
 PlatformUrlsGenerator::PlatformUrlsGenerator(olp::client::Apis apis,
                                              const std::string& layer)
     : apis_(std::make_shared<olp::client::Apis>(apis)), layer_(layer) {}
 
-PlatformUrlsGenerator::PlatformUrlsGenerator(const std::string& endpoint,
-                                             const std::string& catalog,
-                                             const std::string& layer)
+PlatformUrlsGenerator::PlatformUrlsGenerator(const std::string& catalog,
+                                             const std::string& layer,
+                                             const std::string& endpoint)
     : apis_(nullptr),
       http_prefix_(endpoint),
       catalog_(catalog),
@@ -38,14 +41,28 @@ std::string PlatformUrlsGenerator::PartitionsQuery(
     const olp::dataservice::read::PartitionsRequest::PartitionIds& partitions,
     uint64_t version) {
   std::string path = "/layers/" + layer_ + "/partitions?";
-  for (const auto& partition : partitions) {
-    path.append("partition=" + partition + "&");
+  if (!partitions.empty()) {
+    for (const auto& partition : partitions) {
+      path.append("partition=" + partition + "&");
+    }
+    path.append("version=" + std::to_string(version));
   }
-  path.append("version=" + std::to_string(version));
-
   return FullPath("query", path);
 }
 
+std::string PlatformUrlsGenerator::PartitionsMetadata(
+    const olp::dataservice::read::PartitionsRequest::PartitionIds& partitions,
+    uint64_t version) {
+  std::string path = "/layers/" + layer_ + "/partitions?";
+  if (!partitions.empty()) {
+    for (const auto& partition : partitions) {
+      path.append("partition=" + partition + "&");
+    }
+    path.append("version=" + std::to_string(version));
+  }
+  return FullPath("metadata", path);
+}
+
 std::string PlatformUrlsGenerator::DataBlob(const std::string& data_handle) {
   return FullPath("blob", "/layers/" + layer_ + "/data/" + data_handle);
 }
@@ -66,7 +83,29 @@ std::string PlatformUrlsGenerator::FullPath(const std::string& service,
                                             const std::string& path) {
   std::string url;
   if (!apis_) {
-    url = http_prefix_ + "/catalogs/" + catalog_;
+    if (http_prefix_.empty()) {
+      // for mock server used as prefix
+      auto find_version =
+          [&](const std::vector<std::pair<std::string, std::string>>& api)
+          -> std::string {
+        auto it =
+            std::find_if(api.begin(), api.end(),
+                         [&](const std::pair<std::string, std::string>& pair) {
+                           return service.compare(pair.first) == 0;
+                         });
+        if (it != api.end()) {
+          return it->second;
+        }
+        return {};
+      };
+      auto v = find_version(mockserver::ApiDefaultResponses::kResourceApis);
+      if (v.empty()) {
+        v = find_version(mockserver::ApiDefaultResponses::kPlatformApis);
+      }
+      url = "/" + service + "/" + v + "/catalogs/" + catalog_;
+    } else {
+      url = http_prefix_ + "/catalogs/" + catalog_;
+    }
   } else {
     auto it = find_if(apis_->begin(), apis_->end(), [&](olp::client::Api api) {
       return api.GetApi() == service;

tests/common/PlatformUrlsGenerator.h

@@ -31,12 +31,18 @@ class PlatformUrlsGenerator {
  public:
   PlatformUrlsGenerator(olp::client::Apis apis, const std::string& layer);
 
-  PlatformUrlsGenerator(const std::string& endpoint, const std::string& catalog,
-                        const std::string& layer);
+  PlatformUrlsGenerator(const std::string& catalog, const std::string& layer,
+                        const std::string& endpoint = "");
 
   std::string PartitionsQuery(
-      const olp::dataservice::read::PartitionsRequest::PartitionIds& partitions,
-      uint64_t version);
+      const olp::dataservice::read::PartitionsRequest::PartitionIds&
+          partitions = {},
+      uint64_t version = 1);
+
+  std::string PartitionsMetadata(
+      const olp::dataservice::read::PartitionsRequest::PartitionIds&
+          partitions = {},
+      uint64_t version = 1);
 
   std::string DataBlob(const std::string& data_handle);
 

tests/functional/CMakeLists.txt

@@ -25,6 +25,7 @@ set(OLP_SDK_FUNCTIONAL_TESTS_SOURCES
     ./olp-cpp-sdk-dataservice-read/VersionedLayerClientProtectTest.cpp
     ./olp-cpp-sdk-dataservice-read/DataserviceReadVersionedLayerClientTest.cpp
     ./olp-cpp-sdk-dataservice-read/VersionedLayerClientGetDataTest.cpp
+    ./olp-cpp-sdk-dataservice-read/VersionedLayerTestBase.cpp
     ./olp-cpp-sdk-dataservice-read/DataserviceReadVolatileLayerClientTest.cpp
     ./olp-cpp-sdk-dataservice-write/DataserviceWriteIndexLayerClientTest.cpp
     ./olp-cpp-sdk-dataservice-write/DataserviceWriteStreamLayerClientCacheTest.cpp