Add metadata api to get versions list (#895)

Implement MetadataApi function.

Relates-To: OLPEDGE-1606

Signed-off-by: Liubov Didkivska <ext-liubov.didkivska@here.com>

Author: Liubov Didkivska

olp-cpp-sdk-dataservice-read/src/generated/api/MetadataApi.cpp

@@ -30,6 +30,7 @@
 #include "generated/parser/LayerVersionsParser.h"
 #include "generated/parser/PartitionsParser.h"
 #include "generated/parser/VersionResponseParser.h"
+#include "generated/parser/VersionInfosParser.h"
 #include <olp/core/generated/parser/JsonParser.h>
 // clang-format on
 
@@ -53,10 +54,9 @@ std::string concatStringArray(const std::vector<std::string>& strings,
 namespace olp {
 namespace dataservice {
 namespace read {
-using namespace olp::client;
 
 MetadataApi::LayerVersionsResponse MetadataApi::GetLayerVersions(
-    const OlpClient& client, int64_t version,
+    const client::OlpClient& client, std::int64_t version,
     boost::optional<std::string> billing_tag,
     const client::CancellationContext& context) {
   std::multimap<std::string, std::string> header_params;
@@ -74,16 +74,16 @@ MetadataApi::LayerVersionsResponse MetadataApi::GetLayerVersions(
                                      header_params, {}, nullptr, "", context);
 
   if (api_response.status != http::HttpStatusCode::OK) {
-    return ApiError(api_response.status, api_response.response.str());
+    return client::ApiError(api_response.status, api_response.response.str());
   }
 
   return LayerVersionsResponse(
       olp::parser::parse<model::LayerVersions>(api_response.response));
 }
 
 MetadataApi::PartitionsResponse MetadataApi::GetPartitions(
-    const OlpClient& client, const std::string& layer_id,
-    boost::optional<int64_t> version,
+    const client::OlpClient& client, const std::string& layer_id,
+    boost::optional<std::int64_t> version,
     const std::vector<std::string>& additional_fields,
     boost::optional<std::string> range,
     boost::optional<std::string> billing_tag,
@@ -112,15 +112,15 @@ MetadataApi::PartitionsResponse MetadataApi::GetPartitions(
                                      header_params, {}, nullptr, "", context);
 
   if (api_response.status != http::HttpStatusCode::OK) {
-    return ApiError(api_response.status, api_response.response.str());
+    return {{api_response.status, api_response.response.str()}};
   }
 
   return PartitionsResponse(
       olp::parser::parse<model::Partitions>(api_response.response));
 }
 
 MetadataApi::CatalogVersionResponse MetadataApi::GetLatestCatalogVersion(
-    const OlpClient& client, int64_t startVersion,
+    const client::OlpClient& client, std::int64_t startVersion,
     boost::optional<std::string> billing_tag,
     const client::CancellationContext& context) {
   std::multimap<std::string, std::string> header_params;
@@ -138,12 +138,38 @@ MetadataApi::CatalogVersionResponse MetadataApi::GetLatestCatalogVersion(
                                      header_params, {}, nullptr, "", context);
 
   if (api_response.status != http::HttpStatusCode::OK) {
-    return ApiError(api_response.status, api_response.response.str());
+    return {{api_response.status, api_response.response.str()}};
   }
   return CatalogVersionResponse(
       olp::parser::parse<model::VersionResponse>(api_response.response));
 }
 
+MetadataApi::VersionsResponse MetadataApi::ListVersions(
+    const client::OlpClient& client, std::int64_t start_version,
+    std::int64_t end_version, boost::optional<std::string> billing_tag,
+    const client::CancellationContext& context) {
+  std::multimap<std::string, std::string> header_params;
+  header_params.emplace("Accept", "application/json");
+
+  std::multimap<std::string, std::string> query_params;
+  query_params.emplace("startVersion", std::to_string(start_version));
+  query_params.emplace("endVersion", std::to_string(end_version));
+  if (billing_tag) {
+    query_params.emplace("billingTag", *billing_tag);
+  }
+
+  std::string metadata_uri = "/versions";
+
+  auto api_response = client.CallApi(metadata_uri, "GET", query_params,
+                                     header_params, {}, nullptr, "", context);
+
+  if (api_response.status != http::HttpStatusCode::OK) {
+    return {{api_response.status, api_response.response.str()}};
+  }
+  return VersionsResponse(
+      olp::parser::parse<model::VersionInfos>(api_response.response));
+}
+
 }  // namespace read
 
 }  // namespace dataservice

olp-cpp-sdk-dataservice-read/src/generated/api/MetadataApi.h

@@ -26,14 +26,15 @@
 #include <olp/core/client/ApiResponse.h>
 #include <boost/optional.hpp>
 #include "generated/model/LayerVersions.h"
-#include "olp/dataservice/read/model/VersionResponse.h"
 #include "olp/dataservice/read/model/Partitions.h"
+#include "olp/dataservice/read/model/VersionInfos.h"
+#include "olp/dataservice/read/model/VersionResponse.h"
 
 namespace olp {
 namespace client {
 class OlpClient;
 class CancellationContext;
-}
+}  // namespace client
 
 namespace dataservice {
 namespace read {
@@ -42,6 +43,8 @@ namespace read {
  */
 class MetadataApi {
  public:
+  using VersionsResponse =
+      client::ApiResponse<model::VersionInfos, client::ApiError>;
   using PartitionsResponse =
       client::ApiResponse<model::Partitions, client::ApiError>;
 
@@ -116,6 +119,11 @@ class MetadataApi {
       const client::OlpClient& client, int64_t start_version,
       boost::optional<std::string> billing_tag,
       const client::CancellationContext& context);
+
+  static VersionsResponse ListVersions(
+      const client::OlpClient& client, int64_t start_version,
+      int64_t end_version, boost::optional<std::string> billing_tag,
+      const client::CancellationContext& context);
 };
 
 }  // namespace read

olp-cpp-sdk-dataservice-read/tests/CMakeLists.txt

@@ -22,6 +22,7 @@ set(OLP_SDK_DATASERVICE_READ_TEST_SOURCES
     CatalogRepositoryTest.cpp
     DataCacheRepositoryTest.cpp
     DataRepositoryTest.cpp
+    MetadataApiTest.cpp
     ParserTest.cpp
     PartitionsCacheRepositoryTest.cpp
     PartitionsRepositoryTest.cpp

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

@@ -0,0 +1,131 @@
+/*
+ * 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 <gmock/gmock-matchers.h>
+#include <gmock/gmock.h>
+#include <matchers/NetworkUrlMatchers.h>
+#include <mocks/NetworkMock.h>
+#include <olp/core/client/OlpClient.h>
+#include <olp/core/client/OlpClientFactory.h>
+#include <olp/core/client/OlpClientSettingsFactory.h>
+#include "generated/api/MetadataApi.h"
+
+namespace {
+
+constexpr auto kStartVersion = 299;
+constexpr auto kEndVersion = 300;
+constexpr auto kNodeBaseUrl =
+    "https://some.node.base.url/metadata/v1/catalogs/"
+    "hrn:here:data::olp-here-test:hereos-internal-test-v2";
+
+constexpr auto kUrlVersionsList =
+    R"(https://some.node.base.url/metadata/v1/catalogs/hrn:here:data::olp-here-test:hereos-internal-test-v2/versions?endVersion=300&startVersion=299)";
+
+constexpr auto kUrlVersionsListBillingTag =
+    R"(https://some.node.base.url/metadata/v1/catalogs/hrn:here:data::olp-here-test:hereos-internal-test-v2/versions?billingTag=OlpCppSdkTest&endVersion=300&startVersion=299)";
+
+constexpr auto kHttpResponse =
+    R"jsonString({"versions":[{"version":4,"timestamp":1547159598712,"partitionCounts":{"testlayer":5,"testlayer_res":1,"multilevel_testlayer":33, "hype-test-prefetch-2":7,"testlayer_gzip":1,"hype-test-prefetch":7},"dependencies":[ { "hrn":"hrn:here:data::olp-here-test:hereos-internal-test-v2","version":0,"direct":false},{"hrn":"hrn:here:data:::hereos-internal-test-v2","version":0,"direct":false }]}]})jsonString";
+
+using ::testing::_;
+namespace http = olp::http;
+namespace client = olp::client;
+namespace common = olp::tests::common;
+
+class MetadataApiTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    network_mock_ = std::make_shared<common::NetworkMock>();
+
+    settings_ = std::make_shared<client::OlpClientSettings>();
+    settings_->network_request_handler = network_mock_;
+
+    client_ = client::OlpClientFactory::Create(*settings_);
+    client_->SetBaseUrl(kNodeBaseUrl);
+  }
+  void TearDown() override { network_mock_.reset(); }
+
+ protected:
+  std::shared_ptr<client::OlpClientSettings> settings_;
+  std::shared_ptr<client::OlpClient> client_;
+  std::shared_ptr<common::NetworkMock> network_mock_;
+};
+
+TEST_F(MetadataApiTest, GetListVersions) {
+  {
+    SCOPED_TRACE("Request metadata versions.");
+    EXPECT_CALL(*network_mock_,
+                Send(testing::AllOf(common::IsGetRequest(kUrlVersionsList)), _,
+                     _, _, _))
+        .WillOnce(common::ReturnHttpResponse(
+            http::NetworkResponse().WithStatus(http::HttpStatusCode::OK),
+            kHttpResponse));
+
+    auto index_response = olp::dataservice::read::MetadataApi::ListVersions(
+        *client_, kStartVersion, kEndVersion, boost::none,
+        olp::client::CancellationContext{});
+
+    ASSERT_TRUE(index_response.IsSuccessful());
+    auto result = index_response.GetResult();
+
+    ASSERT_EQ(1u, result.GetVersions().size());
+    ASSERT_EQ(4, result.GetVersions().front().GetVersion());
+    ASSERT_EQ(2u, result.GetVersions().front().GetDependencies().size());
+    ASSERT_EQ(6u, result.GetVersions().front().GetPartitionCounts().size());
+  }
+
+  {
+    SCOPED_TRACE("Request with billing tag.");
+    std::string billing_tag = "OlpCppSdkTest";
+    EXPECT_CALL(
+        *network_mock_,
+        Send(testing::AllOf(common::IsGetRequest(kUrlVersionsListBillingTag)),
+             _, _, _, _))
+        .WillOnce(common::ReturnHttpResponse(
+            http::NetworkResponse().WithStatus(http::HttpStatusCode::OK),
+            kHttpResponse));
+
+    auto index_response = olp::dataservice::read::MetadataApi::ListVersions(
+        *client_, kStartVersion, kEndVersion, billing_tag,
+        olp::client::CancellationContext{});
+
+    ASSERT_TRUE(index_response.IsSuccessful());
+    auto result = index_response.GetResult();
+
+    ASSERT_EQ(1u, result.GetVersions().size());
+    ASSERT_EQ(4, result.GetVersions().front().GetVersion());
+    ASSERT_EQ(2u, result.GetVersions().front().GetDependencies().size());
+    ASSERT_EQ(6u, result.GetVersions().front().GetPartitionCounts().size());
+  }
+  {
+    SCOPED_TRACE("Cancelled CancellationContext");
+
+    auto context = olp::client::CancellationContext();
+    context.CancelOperation();
+
+    auto index_response = olp::dataservice::read::MetadataApi::ListVersions(
+        *client_, kStartVersion, kEndVersion, boost::none, context);
+
+    ASSERT_FALSE(index_response.IsSuccessful());
+    auto error = index_response.GetError();
+    ASSERT_EQ(olp::client::ErrorCode::Cancelled, error.GetErrorCode());
+  }
+}
+
+}  // namespace