RemoveFromCache by TileKey for VersionedLayerClient (#727)

Overloading RemoveFromCache() method with TileKey input. Its reusing
previous method implementation, so added integration and unit tests are
similar.

Resolves: OLPEDGE-1567

Signed-off-by: Kostiantyn Zvieriev <[email protected]>

Author: kzvieriev

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

@@ -331,6 +331,15 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    */
   bool RemoveFromCache(const std::string& partition_id);
 
+  /**
+   * @brief Removes the tile from the mutable disk cache.
+   *
+   * @param tile The tile key that should be removed.
+   *
+   * @return True if tile data is removed successfully; false otherwise.
+   */
+  bool RemoveFromCache(const geo::TileKey& tile);
+
  private:
   std::unique_ptr<VersionedLayerClientImpl> impl_;
 };

olp-cpp-sdk-dataservice-read/src/VersionedLayerClient.cpp

@@ -98,6 +98,11 @@ bool VersionedLayerClient::RemoveFromCache(const std::string& partition_id) {
   return impl_->RemoveFromCache(partition_id);
 }
 
+bool VersionedLayerClient::RemoveFromCache(const geo::TileKey& tile) {
+  return impl_->RemoveFromCache(tile);
+}
+
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.cpp

@@ -498,6 +498,11 @@ bool VersionedLayerClientImpl::RemoveFromCache(
   return data_repository.Clear(layer_id_, partition.get().GetDataHandle());
 }
 
+bool VersionedLayerClientImpl::RemoveFromCache(const geo::TileKey& tile) {
+  auto partition_id = tile.ToHereTile();
+  return RemoveFromCache(partition_id);
+}
+
 PORTING_POP_WARNINGS()
 }  // namespace read
 }  // namespace dataservice

olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.h

@@ -83,6 +83,8 @@ class VersionedLayerClientImpl {
 
   virtual bool RemoveFromCache(const std::string& partition_id);
 
+  virtual bool RemoveFromCache(const geo::TileKey& tile);
+
  private:
   CatalogVersionResponse GetVersion(boost::optional<std::string> billing_tag,
                                     const FetchOptions& fetch_options,

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

@@ -76,7 +76,7 @@ TEST(VersionedLayerClientTest, GetData) {
   }
 }
 
-TEST(VersionedLayerClientTest, RemoveFromCache) {
+TEST(VersionedLayerClientTest, RemoveFromCachePartition) {
   olp::client::OlpClientSettings settings;
   std::shared_ptr<CacheMock> cache_mock = std::make_shared<CacheMock>();
   settings.cache = cache_mock;
@@ -138,4 +138,67 @@ TEST(VersionedLayerClientTest, RemoveFromCache) {
   }
 }
 
+TEST(VersionedLayerClientTest, RemoveFromCacheTileKey) {
+  olp::client::OlpClientSettings settings;
+  std::shared_ptr<CacheMock> cache_mock = std::make_shared<CacheMock>();
+  settings.cache = cache_mock;
+
+  // successfull mock cache calls
+  auto found_cache_response = [](const std::string& key,
+                                 const olp::cache::Decoder& encoder) {
+    auto partition = model::Partition();
+    partition.SetPartition(kPartitionId);
+    partition.SetDataHandle(kBlobDataHandle);
+    return partition;
+  };
+  auto partition_cache_remove = [&](const std::string& prefix) {
+    std::string expected_prefix =
+        kHrn.ToCatalogHRNString() + "::" + kLayerId + "::" + kPartitionId +
+        "::" + std::to_string(kCatalogVersion) + "::partition";
+    EXPECT_EQ(prefix, expected_prefix);
+    return true;
+  };
+  auto data_cache_remove = [&](const std::string& prefix) {
+    std::string expected_prefix = kHrn.ToCatalogHRNString() + "::" + kLayerId +
+                                  "::" + kBlobDataHandle + "::Data";
+    EXPECT_EQ(prefix, expected_prefix);
+    return true;
+  };
+
+  auto tile_key = olp::geo::TileKey::FromHereTile(kPartitionId);
+  VersionedLayerClient client(kHrn, kLayerId, kCatalogVersion, settings);
+  {
+    SCOPED_TRACE("Successfull remove tile from cache");
+
+    EXPECT_CALL(*cache_mock, Get(_, _)).WillOnce(found_cache_response);
+    EXPECT_CALL(*cache_mock, RemoveKeysWithPrefix(_))
+        .WillOnce(partition_cache_remove)
+        .WillOnce(data_cache_remove);
+    ASSERT_TRUE(client.RemoveFromCache(tile_key));
+  }
+  {
+    SCOPED_TRACE("Remove not existing tile from cache");
+    EXPECT_CALL(*cache_mock, Get(_, _))
+        .WillOnce([](const std::string&, const olp::cache::Decoder&) {
+          return boost::any();
+        });
+    ASSERT_TRUE(client.RemoveFromCache(tile_key));
+  }
+  {
+    SCOPED_TRACE("Partition cache failure");
+    EXPECT_CALL(*cache_mock, Get(_, _)).WillOnce(found_cache_response);
+    EXPECT_CALL(*cache_mock, RemoveKeysWithPrefix(_))
+        .WillOnce([](const std::string&) { return false; });
+    ASSERT_FALSE(client.RemoveFromCache(tile_key));
+  }
+  {
+    SCOPED_TRACE("Data cache failure");
+    EXPECT_CALL(*cache_mock, Get(_, _)).WillOnce(found_cache_response);
+    EXPECT_CALL(*cache_mock, RemoveKeysWithPrefix(_))
+        .WillOnce(partition_cache_remove)
+        .WillOnce([](const std::string&) { return false; });
+    ASSERT_FALSE(client.RemoveFromCache(tile_key));
+  }
+}
+
 }  // namespace

tests/integration/olp-cpp-sdk-dataservice-read/VersionedLayerClientTest.cpp

@@ -2795,7 +2795,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetTileTwoSequentialCalls) {
   }
 }
 
-TEST_F(DataserviceReadVersionedLayerClientTest, RemoveFromCache) {
+TEST_F(DataserviceReadVersionedLayerClientTest, RemoveFromCachePartition) {
   EXPECT_CALL(*network_mock_, Send(_, _, _, _, _))
       .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
                                        olp::http::HttpStatusCode::OK),
@@ -2853,4 +2853,63 @@ TEST_F(DataserviceReadVersionedLayerClientTest, RemoveFromCache) {
   ASSERT_FALSE(response.IsSuccessful());
 }
 
+TEST_F(DataserviceReadVersionedLayerClientTest, RemoveFromCacheTileKey) {
+  EXPECT_CALL(*network_mock_, Send(_, _, _, _, _))
+      .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
+                                       olp::http::HttpStatusCode::OK),
+                                   kHttpResponseLookupQuery))
+      .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
+                                       olp::http::HttpStatusCode::OK),
+                                   kHttpResponsePartition_269))
+      .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
+                                       olp::http::HttpStatusCode::OK),
+                                   kHttpResponseLookupBlob))
+      .WillOnce(ReturnHttpResponse(olp::http::NetworkResponse().WithStatus(
+                                       olp::http::HttpStatusCode::OK),
+                                   kHttpResponseBlobData_269));
+
+  auto catalog = olp::client::HRN::FromString(
+      GetArgument("dataservice_read_test_catalog"));
+  auto layer = GetArgument("dataservice_read_test_layer");
+  auto version = std::stoi(GetArgument("dataservice_read_test_layer_version"));
+
+  auto client = std::make_unique<olp::dataservice::read::VersionedLayerClient>(
+      catalog, layer, version, *settings_);
+  ASSERT_TRUE(client);
+
+  // load and cache some data
+  auto promise = std::make_shared<std::promise<DataResponse>>();
+  auto future = promise->get_future();
+  auto partition = GetArgument("dataservice_read_test_partition");
+  auto data_request =
+      olp::dataservice::read::DataRequest().WithPartitionId(partition);
+  auto token = client->GetData(data_request, [promise](DataResponse response) {
+    promise->set_value(response);
+  });
+
+  ASSERT_NE(future.wait_for(kWaitTimeout), std::future_status::timeout);
+  DataResponse response = future.get();
+
+  ASSERT_TRUE(response.IsSuccessful()) << response.GetError().GetMessage();
+  ASSERT_NE(response.GetResult(), nullptr);
+  ASSERT_NE(response.GetResult()->size(), 0u);
+
+  // remove the data from cache
+  auto tile_key = olp::geo::TileKey::FromHereTile(partition);
+  ASSERT_TRUE(client->RemoveFromCache(tile_key));
+
+  // check the data is not available in cache
+  promise = std::make_shared<std::promise<DataResponse>>();
+  future = promise->get_future();
+  data_request.WithFetchOption(CacheOnly);
+  token = client->GetData(data_request, [promise](DataResponse response) {
+    promise->set_value(response);
+  });
+
+  ASSERT_NE(future.wait_for(kWaitTimeout), std::future_status::timeout);
+  response = future.get();
+
+  ASSERT_FALSE(response.IsSuccessful());
+}
+
 }  // namespace