Save latest version with GetLatestVersion request (#1293)

When user is using fixed catalog versions it is possible that request
GetLatestVersion won't return actual version from the cache since it
hadn't been written to the cache. Use StartVersion as a new latest
version in the cache-only requests when previous version is absent or
less than the user-set version

Relates-To: OAM-1387
Signed-off-by: Andrey Kashcheev <[email protected]>

Author: andrey-kashcheev

olp-cpp-sdk-dataservice-read/include/olp/dataservice/read/CatalogClient.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2020 HERE Europe B.V.
+ * Copyright (C) 2019-2021 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.
@@ -119,6 +119,14 @@ class DATASERVICE_READ_API CatalogClient final {
   /**
    * @brief Gets the catalog version asynchronously.
    *
+   * @note In case you call this API with `FetchOptions::CacheOnly` and a valid
+   * version in `CatalogVersionRequest::WithStartVersion()`, i.e. >= 0, then
+   * please make sure that the provided version is a existing catalog version as
+   * it will be written for later use to the cache as latest version in the
+   * following cases:
+   * - There is no latest version yet written to cache.
+   * - The latest version written to cache is less then the provided version.
+   *
    * @param request The `CatalogVersionRequest` instance that contains
    * a complete set of request parameters.
    * @param callback The `CatalogVersionCallback` object that is invoked if
@@ -132,6 +140,14 @@ class DATASERVICE_READ_API CatalogClient final {
   /**
    * @brief Gets the catalog version asynchronously.
    *
+   * @note In case you call this API with `FetchOptions::CacheOnly` and a valid
+   * version in `CatalogVersionRequest::WithStartVersion()`, i.e. >= 0, then
+   * please make sure that the provided version is a existing catalog version as
+   * it will be written for later use to the cache as latest version in the
+   * following cases:
+   * - There is no latest version yet written to cache.
+   * - The latest version written to cache is less then the provided version.
+   *
    * @param request The `CatalogVersionRequest` instance that contains
    * a complete set of request parameters.
    *

olp-cpp-sdk-dataservice-read/src/repositories/CatalogRepository.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2020 HERE Europe B.V.
+ * Copyright (C) 2019-2021 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.
@@ -110,13 +110,14 @@ CatalogVersionResponse CatalogRepository::GetLatestVersion(
       catalog_, settings_.cache, settings_.default_cache_expiration);
 
   const auto fetch_option = request.GetFetchOption();
-  // in case if get version online was never called and version was not found in
+  // in case get version online was never called and version was not found in
   // cache
   CatalogVersionResponse version_response = {
       {client::ErrorCode::NotFound, "Failed to find version."}};
 
   if (fetch_option != CacheOnly) {
-    version_response = GetLatestVersionOnline(request.GetBillingTag(), context);
+    version_response =
+        GetLatestVersionOnline(request.GetBillingTag(), std::move(context));
 
     if (fetch_option == OnlineOnly) {
       return version_response;
@@ -135,26 +136,48 @@ CatalogVersionResponse CatalogRepository::GetLatestVersion(
     }
   }
 
-  const auto cached_version = repository.GetVersion();
+  auto cached_version = repository.GetVersion();
+
+  // Using `GetStartVersion` to set up new latest version for CacheOnly
+  // requests in case of absence of previous latest version or it less than the
+  // new user set version
+  if (fetch_option == CacheOnly) {
+    constexpr auto kDefaultStartVersion = 0;
+
+    auto user_set_version = request.GetStartVersion();
+    if (user_set_version != kDefaultStartVersion) {
+      if (!cached_version || user_set_version > cached_version->GetVersion()) {
+        model::VersionResponse new_response;
+        new_response.SetVersion(user_set_version);
+        version_response = new_response;
+      }
+    }
+  }
 
   if (version_response.IsSuccessful()) {
-    const auto online_version = version_response.GetResult().GetVersion();
+    const auto new_version = version_response.GetResult().GetVersion();
     // Write or update the version in cache, updating happens only when the new
     // version is greater than cached.
-    if (!cached_version || (*cached_version).GetVersion() < online_version) {
+    if (!cached_version || (*cached_version).GetVersion() < new_version) {
       repository.PutVersion(version_response.GetResult());
-      OLP_SDK_LOG_DEBUG_F(
-          kLogTag, "Latest online version, hrn='%s', version=%" PRId64,
-          catalog_.ToCatalogHRNString().c_str(), online_version);
+      if (fetch_option == CacheOnly) {
+        OLP_SDK_LOG_DEBUG_F(
+            kLogTag, "Latest user set version, hrn='%s', version=%" PRId64,
+            catalog_.ToCatalogHRNString().c_str(), new_version);
+      } else {
+        OLP_SDK_LOG_DEBUG_F(kLogTag,
+                            "Latest online version, hrn='%s', version=%" PRId64,
+                            catalog_.ToCatalogHRNString().c_str(), new_version);
+      }
     }
     return version_response;
   }
 
   if (cached_version) {
-    version_response = std::move(*cached_version);
     OLP_SDK_LOG_DEBUG_F(
         kLogTag, "Latest cached version, hrn='%s', version=%" PRId64,
         catalog_.ToCatalogHRNString().c_str(), (*cached_version).GetVersion());
+    version_response = *std::move(cached_version);
   }
 
   return version_response;

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

@@ -85,7 +85,7 @@ const auto kHrn = olp::client::HRN::FromString(kCatalog);
 class CatalogRepositoryTest : public ::testing::Test {
  protected:
   void SetUp() override {
-    cache_ = std::make_shared<testing::NiceMock<CacheMock>>();
+    cache_ = std::make_shared<testing::NaggyMock<CacheMock>>();
     network_ = std::make_shared<testing::NiceMock<NetworkMock>>();
 
     settings_.network_request_handler = network_;
@@ -160,6 +160,36 @@ TEST_F(CatalogRepositoryTest, GetLatestVersionCacheOnlyNotFound) {
             olp::client::ErrorCode::NotFound);
 }
 
+TEST_F(CatalogRepositoryTest, GetLatestVersionCacheOnlyRequestWithMinVersion) {
+  olp::client::CancellationContext context;
+
+  auto request = read::CatalogVersionRequest();
+  request.WithFetchOption(olp::dataservice::read::CacheOnly)
+      .WithStartVersion(kStartVersion);
+
+  EXPECT_CALL(*cache_, Get(_, _))
+      .Times(1)
+      .WillOnce(testing::Return(boost::any{}));
+
+  EXPECT_CALL(*cache_, Put(_, _, _, _)).Times(1);
+
+  ON_CALL(*network_, Send(_, _, _, _, _))
+      .WillByDefault([](olp::http::NetworkRequest, olp::http::Network::Payload,
+                        olp::http::Network::Callback,
+                        olp::http::Network::HeaderCallback,
+                        olp::http::Network::DataCallback) {
+        ADD_FAILURE() << "Should not be called with CacheOnly";
+        return olp::http::SendOutcome(olp::http::ErrorCode::UNKNOWN_ERROR);
+      });
+
+  ApiLookupClient lookup_client(kHrn, settings_);
+  repository::CatalogRepository repository(kHrn, settings_, lookup_client);
+  auto response = repository.GetLatestVersion(request, context);
+
+  EXPECT_TRUE(response.IsSuccessful());
+  EXPECT_EQ(response.GetResult().GetVersion(), kStartVersion);
+}
+
 TEST_F(CatalogRepositoryTest, GetLatestVersionOnlineOnlyNotFound) {
   olp::client::CancellationContext context;