Add responses generator to test-common lib. (#1082)

Integration tests should have dependency only
from public dataservice api. Move generating
urls and responses to test-common lib.

Relates-To: OLPEDGE-1901

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

Author: Liubov Didkivska

olp-cpp-sdk-dataservice-read/tests/VersionedLayerClientImplTest.cpp

@@ -29,8 +29,9 @@
 #include <olp/core/utils/Dir.h>
 #include <olp/dataservice/read/VersionedLayerClient.h>
 #include "ApiDefaultResponses.h"
+#include "PlatformUrlsGenerator.h"
 #include "ReadDefaultResponses.h"
-#include "UrlGenerators.h"
+#include "ResponseGenerator.h"
 #include "VersionedLayerClientImpl.h"
 #include "repositories/QuadTreeIndex.h"
 // clang-format off
@@ -60,17 +61,6 @@ constexpr auto kOtherHereTile2 = "5904591";
 constexpr auto kUrlLookup =
     R"(https://api-lookup.data.api.platform.here.com/lookup/v1/resources/hrn:here:data::olp-here-test:hereos-internal-test-v2/apis)";
 
-template <class T>
-std::string serialize(std::vector<T> data) {
-  std::string str = "[";
-  for (const auto& el : data) {
-    str.append(olp::serializer::serialize(el));
-    str.append(",");
-  }
-  str[str.length() - 1] = ']';
-  return str;
-}
-
 TEST(VersionedLayerClientTest, CanBeMoved) {
   read::VersionedLayerClient client_a(olp::client::HRN(), "", boost::none, {});
   read::VersionedLayerClient client_b(std::move(client_a));
@@ -363,33 +353,22 @@ TEST(VersionedLayerClientTest, ProtectThanRelease) {
   settings.default_cache_expiration = std::chrono::seconds(2);
   settings.network_request_handler = network_mock;
   auto version = 4u;
-  auto api_response =
-      mockserver::ApiDefaultResponses::GenerateResourceApisResponse(kCatalog);
-  auto quad_path = mock::GeneratePath(
-      api_response, "query",
-      mock::GenerateGetQuadKeyPath("92259", kLayerId, version, 4));
+  auto api_response = ResponseGenerator::ResourceApis(kCatalog);
+  PlatformUrlsGenerator generator(api_response, kLayerId);
+  auto quad_path = generator.VersionedQuadTree("92259", version, 4);
   ASSERT_FALSE(quad_path.empty());
   auto tile_key = olp::geo::TileKey::FromHereTile(kHereTile);
   auto responce_quad =
       mockserver::ReadDefaultResponses::GenerateQuadTreeResponse(
           tile_key.ChangedLevelBy(-4), 4, {9, 10, 11, 12});
-  auto tile_path = mock::GeneratePath(
-      api_response, "blob",
-      mock::GenerateGetDataPath(
-          kLayerId,
-          mockserver::ReadDefaultResponses::GenerateDataHandle(kHereTile)));
+  auto tile_path = generator.DataBlob(
+      mockserver::ReadDefaultResponses::GenerateDataHandle(kHereTile));
   ASSERT_FALSE(tile_path.empty());
-  auto tile2_path = mock::GeneratePath(
-      api_response, "blob",
-      mock::GenerateGetDataPath(
-          kLayerId, mockserver::ReadDefaultResponses::GenerateDataHandle(
-                        kOtherHereTile2)));
+  auto tile2_path = generator.DataBlob(
+      mockserver::ReadDefaultResponses::GenerateDataHandle(kOtherHereTile2));
   ASSERT_FALSE(tile2_path.empty());
-  auto other_tile_path = mock::GeneratePath(
-      api_response, "blob",
-      mock::GenerateGetDataPath(
-          kLayerId, mockserver::ReadDefaultResponses::GenerateDataHandle(
-                        kOtherHereTile)));
+  auto other_tile_path = generator.DataBlob(
+      mockserver::ReadDefaultResponses::GenerateDataHandle(kOtherHereTile));
   ASSERT_FALSE(other_tile_path.empty());
 
   read::VersionedLayerClientImpl client(kHrn, kLayerId, boost::none, settings);
@@ -399,9 +378,8 @@ TEST(VersionedLayerClientTest, ProtectThanRelease) {
     EXPECT_CALL(*network_mock, Send(IsGetRequest(kUrlLookup), _, _, _, _))
         .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
                                          olp::http::HttpStatusCode::OK),
-                                     serialize(api_response)));
-    auto version_path = mock::GeneratePath(
-        api_response, "metadata", mock::GenerateGetLatestVersionPath());
+                                     api_response));
+    auto version_path = generator.LatestVersion();
     ASSERT_FALSE(version_path.empty());
     EXPECT_CALL(*network_mock, Send(IsGetRequest(version_path), _, _, _, _))
         .WillOnce(ReturnHttpResponse(
@@ -574,8 +552,8 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSplitted) {
   {
     SCOPED_TRACE("Prefetch multiple partitions");
 
-    auto api_response =
-        mockserver::ApiDefaultResponses::GenerateResourceApisResponse(kCatalog);
+    auto api_response = ResponseGenerator::ResourceApis(kCatalog);
+    PlatformUrlsGenerator generator(api_response, kLayerId);
     auto partitions_response1 =
         mockserver::ReadDefaultResponses::GeneratePartitionsResponse(
             partitions_count / 2);
@@ -586,10 +564,9 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSplitted) {
     EXPECT_CALL(*network_mock, Send(IsGetRequest(kUrlLookup), _, _, _, _))
         .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
                                          olp::http::HttpStatusCode::OK),
-                                     serialize(api_response)));
+                                     api_response));
 
-    auto version_path = mock::GeneratePath(
-        api_response, "metadata", mock::GenerateGetLatestVersionPath());
+    auto version_path = generator.LatestVersion();
     ASSERT_FALSE(version_path.empty());
 
     EXPECT_CALL(*network_mock, Send(IsGetRequest(version_path), _, _, _, _))
@@ -600,13 +577,9 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSplitted) {
                 mockserver::ReadDefaultResponses::GenerateVersionResponse(
                     version))));
 
-    auto partitions_path1 = mock::GeneratePath(
-        api_response, "query",
-        mock::GenerateGetPartitionsPath(kLayerId, partitions1, version));
+    auto partitions_path1 = generator.PartitionsQuery(partitions1, version);
     ASSERT_FALSE(partitions_path1.empty());
-    auto partitions_path2 = mock::GeneratePath(
-        api_response, "query",
-        mock::GenerateGetPartitionsPath(kLayerId, partitions2, version));
+    auto partitions_path2 = generator.PartitionsQuery(partitions2, version);
     ASSERT_FALSE(partitions_path2.empty());
 
     EXPECT_CALL(*network_mock, Send(IsGetRequest(partitions_path1), _, _, _, _))
@@ -621,9 +594,7 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSplitted) {
             olp::serializer::serialize(partitions_response2)));
 
     for (const auto& partition : partitions_response1.GetPartitions()) {
-      auto partition_path = mock::GeneratePath(
-          api_response, "blob",
-          mock::GenerateGetDataPath(kLayerId, partition.GetDataHandle()));
+      auto partition_path = generator.DataBlob(partition.GetDataHandle());
       ASSERT_FALSE(partition_path.empty());
 
       EXPECT_CALL(*network_mock, Send(IsGetRequest(partition_path), _, _, _, _))
@@ -633,9 +604,7 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSplitted) {
     }
 
     for (const auto& partition : partitions_response2.GetPartitions()) {
-      auto partition_path = mock::GeneratePath(
-          api_response, "blob",
-          mock::GenerateGetDataPath(kLayerId, partition.GetDataHandle()));
+      auto partition_path = generator.DataBlob(partition.GetDataHandle());
       ASSERT_FALSE(partition_path.empty());
 
       EXPECT_CALL(*network_mock, Send(IsGetRequest(partition_path), _, _, _, _))
@@ -704,29 +673,26 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSomeFail) {
   for (auto i = 0u; i < partitions_count; i++) {
     partitions.emplace_back(std::to_string(i));
   }
-  auto api_response =
-      mockserver::ApiDefaultResponses::GenerateResourceApisResponse(kCatalog);
+  auto api_response = ResponseGenerator::ResourceApis(kCatalog);
+  PlatformUrlsGenerator generator(api_response, kLayerId);
   auto partitions_response =
       mockserver::ReadDefaultResponses::GeneratePartitionsResponse(
           partitions_count);
   const auto request =
       olp::dataservice::read::PrefetchPartitionsRequest().WithPartitionIds(
           partitions);
   read::VersionedLayerClientImpl client(kHrn, kLayerId, boost::none, settings);
-  auto partitions_path = mock::GeneratePath(
-      api_response, "query",
-      mock::GenerateGetPartitionsPath(kLayerId, partitions, version));
+  auto partitions_path = generator.PartitionsQuery(partitions, version);
   ASSERT_FALSE(partitions_path.empty());
   {
     SCOPED_TRACE("Prefetch partitions, some fails");
 
     EXPECT_CALL(*network_mock, Send(IsGetRequest(kUrlLookup), _, _, _, _))
         .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
                                          olp::http::HttpStatusCode::OK),
-                                     serialize(api_response)));
+                                     api_response));
 
-    auto version_path = mock::GeneratePath(
-        api_response, "metadata", mock::GenerateGetLatestVersionPath());
+    auto version_path = generator.LatestVersion();
     ASSERT_FALSE(version_path.empty());
 
     EXPECT_CALL(*network_mock, Send(IsGetRequest(version_path), _, _, _, _))
@@ -746,9 +712,7 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSomeFail) {
             olp::serializer::serialize(partitions_response)));
     for (auto i = 0u; i < partitions_response.GetPartitions().size(); i++) {
       const auto& partition = partitions_response.GetPartitions().at(i);
-      auto partition_path = mock::GeneratePath(
-          api_response, "blob",
-          mock::GenerateGetDataPath(kLayerId, partition.GetDataHandle()));
+      auto partition_path = generator.DataBlob(partition.GetDataHandle());
       ASSERT_FALSE(partition_path.empty());
 
       EXPECT_CALL(*network_mock, Send(IsGetRequest(partition_path), _, _, _, _))
@@ -800,9 +764,7 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsSomeFail) {
 
     for (auto i = 0u; i < partitions_response.GetPartitions().size(); i++) {
       const auto& partition = partitions_response.GetPartitions().at(i);
-      auto partition_path = mock::GeneratePath(
-          api_response, "blob",
-          mock::GenerateGetDataPath(kLayerId, partition.GetDataHandle()));
+      auto partition_path = generator.DataBlob(partition.GetDataHandle());
       ASSERT_FALSE(partition_path.empty());
 
       EXPECT_CALL(*network_mock, Send(IsGetRequest(partition_path), _, _, _, _))
@@ -846,15 +808,13 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsFail) {
   for (auto i = 0u; i < partitions_count; i++) {
     partitions.emplace_back(std::to_string(i));
   }
-  auto api_response =
-      mockserver::ApiDefaultResponses::GenerateResourceApisResponse(kCatalog);
+  auto api_response = ResponseGenerator::ResourceApis(kCatalog);
+  PlatformUrlsGenerator generator(api_response, kLayerId);
   const auto request =
       olp::dataservice::read::PrefetchPartitionsRequest().WithPartitionIds(
           partitions);
   read::VersionedLayerClientImpl client(kHrn, kLayerId, boost::none, settings);
-  auto partitions_path = mock::GeneratePath(
-      api_response, "query",
-      mock::GenerateGetPartitionsPath(kLayerId, partitions, version));
+  auto partitions_path = generator.PartitionsQuery(partitions, version);
   ASSERT_FALSE(partitions_path.empty());
   {
     SCOPED_TRACE("Prefetch partitions, empty request");
@@ -881,10 +841,9 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsFail) {
     EXPECT_CALL(*network_mock, Send(IsGetRequest(kUrlLookup), _, _, _, _))
         .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
                                          olp::http::HttpStatusCode::OK),
-                                     serialize(api_response)));
+                                     api_response));
 
-    auto version_path = mock::GeneratePath(
-        api_response, "metadata", mock::GenerateGetLatestVersionPath());
+    auto version_path = generator.LatestVersion();
     ASSERT_FALSE(version_path.empty());
 
     EXPECT_CALL(*network_mock, Send(IsGetRequest(version_path), _, _, _, _))
@@ -915,8 +874,7 @@ TEST(VersionedLayerClientTest, PrefetchPartitionsFail) {
   {
     SCOPED_TRACE("Get data handles fails");
 
-    auto version_path = mock::GeneratePath(
-        api_response, "metadata", mock::GenerateGetLatestVersionPath());
+    auto version_path = generator.LatestVersion();
     ASSERT_FALSE(version_path.empty());
     EXPECT_CALL(*network_mock, Send(IsGetRequest(version_path), _, _, _, _))
         .WillOnce(ReturnHttpResponse(

tests/common/ApiDefaultResponses.h

@@ -23,11 +23,6 @@
 #include <utility>
 #include <vector>
 
-#include <olp/core/generated/serializer/SerializerWrapper.h>
-#include <rapidjson/document.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/writer.h>
-
 #include "generated/model/Api.h"
 
 namespace mockserver {

tests/common/CMakeLists.txt

@@ -22,12 +22,16 @@ set(OLP_SDK_TESTS_COMMON_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/ApiDefaultResponses.h
     ${CMAKE_CURRENT_SOURCE_DIR}/ReadDefaultResponses.h
     ${CMAKE_CURRENT_SOURCE_DIR}/WriteDefaultResponses.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/PlatformUrlsGenerator.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/ResponseGenerator.h
 )
 
 set(OLP_SDK_TESTS_COMMON_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/mocks/CacheMock.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mocks/NetworkMock.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ReadDefaultResponses.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/PlatformUrlsGenerator.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/ResponseGenerator.cpp
 )
 
 add_library(olp-cpp-sdk-tests-common
@@ -38,6 +42,11 @@ target_include_directories(olp-cpp-sdk-tests-common PUBLIC
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>"
 )
 
+target_include_directories(olp-cpp-sdk-tests-common 
+    PRIVATE 
+        ${CMAKE_CURRENT_SOURCE_DIR}/../../olp-cpp-sdk-dataservice-read/src/
+)
+
 target_link_libraries(olp-cpp-sdk-tests-common
     PUBLIC
         gmock

tests/common/PlatformUrlsGenerator.cpp

@@ -0,0 +1,78 @@
+/*
+ * 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 "PlatformUrlsGenerator.h"
+
+#include <string>
+#include <vector>
+
+// clang-format off
+#include "generated/parser/ApiParser.h"
+#include <olp/core/generated/parser/JsonParser.h>
+// clang-format on
+#include <olp/dataservice/read/model/Partitions.h>
+#include <olp/dataservice/read/model/VersionResponse.h>
+#include "generated/model/Api.h"
+
+PlatformUrlsGenerator::PlatformUrlsGenerator(const std::string& apis,
+                                             const std::string& layer)
+    : apis_(std::make_shared<olp::dataservice::read::model::Apis>(
+          olp::parser::parse<olp::dataservice::read::model::Apis>(apis))),
+      layer_(layer) {}
+
+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 + "&");
+  }
+  path.append("version=" + std::to_string(version));
+
+  return FullPath("query", path);
+}
+
+std::string PlatformUrlsGenerator::DataBlob(const std::string& data_handle) {
+  return FullPath("blob", "/layers/" + layer_ + "/data/" + data_handle);
+}
+
+std::string PlatformUrlsGenerator::LatestVersion() {
+  return FullPath("metadata", "/versions/latest?startVersion=-1");
+}
+
+std::string PlatformUrlsGenerator::VersionedQuadTree(const std::string& quadkey,
+                                                     uint64_t version,
+                                                     uint64_t depth) {
+  auto path = "/layers/" + layer_ + "/versions/" + std::to_string(version) +
+              "/quadkeys/" + quadkey + "/depths/" + std::to_string(depth);
+  return FullPath("query", path);
+}
+
+std::string PlatformUrlsGenerator::FullPath(const std::string& api_type,
+                                            const std::string& path) {
+  auto it = find_if(apis_->begin(), apis_->end(),
+                    [&](olp::dataservice::read::model::Api api) {
+                      return api.GetApi() == api_type;
+                    });
+  if (it == apis_->end()) {
+    return {};
+  }
+  auto url = it->GetBaseUrl();
+  return url.append(path);
+}