Add expiration cache test for lookup api. (#743)

* Add expiration cache test for lookup api.

Create mock cache. Run get data for VersionedLayerClient.
Check if lookup api data are stored in cache with expiration time equal
1 hour(3600 seconds). Write core test to check cache expiration. Write
data with expiration 1 second. Get data from cache to check if data was
stored corectly. Wait 2 seconds and try to get data again. Data should
be expired.

Relates-To: OLPEDGE-1612

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

Author: Liubov Didkivska

tests/integration/CMakeLists.txt

@@ -33,6 +33,7 @@ set(OLP_SDK_INTEGRATIONAL_TESTS_SOURCES
     ./olp-cpp-sdk-dataservice-write/StreamLayerClientTest.cpp
     ./olp-cpp-sdk-dataservice-write/VolatileLayerClientTest.cpp
     ./olp-cpp-sdk-core/DefaultNetworkTest.cpp
+    ./olp-cpp-sdk-core/DefaultCacheTest.cpp
 )
 
 if (ANDROID OR IOS)

tests/integration/olp-cpp-sdk-core/DefaultCacheTest.cpp

@@ -0,0 +1,64 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <thread>
+
+#include <olp/core/cache/DefaultCache.h>
+
+namespace {
+using namespace olp::cache;
+
+TEST(DefaultCacheTest, DataExpiration) {
+  const std::string content_key = "test_key";
+  CacheSettings settings;
+  settings.max_memory_cache_size = 5;  // bytes
+  settings.disk_path_mutable = "./cache";
+  const auto expire_time = 1;
+
+  {
+    SCOPED_TRACE("Create a disk cache, write data.");
+    DefaultCache cache(settings);
+    EXPECT_EQ(cache.Open(), DefaultCache::StorageOpenResult::Success);
+
+    const std::string content = "12345";
+    auto buffer = std::make_shared<std::vector<unsigned char>>(
+        std::begin(content), std::end(content));
+    EXPECT_TRUE(cache.Put(content_key, buffer, expire_time));
+    // check if data is in cache
+    auto buffer_out_1 = cache.Get(content_key);
+    ASSERT_NE(buffer_out_1, nullptr);
+    cache.Close();
+  }
+
+  std::this_thread::sleep_for(std::chrono::seconds(expire_time + 1));
+
+  {
+    SCOPED_TRACE("Check that data is expired after timeout.");
+    DefaultCache cache(settings);
+    EXPECT_EQ(cache.Open(), DefaultCache::StorageOpenResult::Success);
+
+    auto buffer = cache.Get(content_key);
+    ASSERT_EQ(buffer, nullptr);
+
+    cache.Close();
+  }
+}
+
+}  // namespace

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

@@ -22,12 +22,16 @@
 #include <string>
 
 #include <matchers/NetworkUrlMatchers.h>
+#include <mocks/CacheMock.h>
 #include <mocks/NetworkMock.h>
 #include <olp/authentication/Settings.h>
+#include <olp/core/cache/CacheSettings.h>
+#include <olp/core/cache/KeyValueCache.h>
 #include <olp/core/client/OlpClientSettings.h>
 #include <olp/core/client/OlpClientSettingsFactory.h>
 #include <olp/core/porting/make_unique.h>
 #include <olp/dataservice/read/VersionedLayerClient.h>
+#include <olp/dataservice/read/model/Partitions.h>
 
 #include "HttpResponses.h"
 
@@ -2912,4 +2916,76 @@ TEST_F(DataserviceReadVersionedLayerClientTest, RemoveFromCacheTileKey) {
   ASSERT_FALSE(response.IsSuccessful());
 }
 
+TEST_F(DataserviceReadVersionedLayerClientTest, CheckLookupApiCacheExpiration) {
+  olp::client::HRN hrn(GetTestCatalog());
+
+  // initialize mock cache
+  auto cache = std::make_shared<testing::StrictMock<CacheMock>>();
+  settings_->cache = cache;
+
+  auto client = olp::dataservice::read::VersionedLayerClient(
+      hrn, "testlayer", 4, *settings_);
+
+  // check if expiration time is 1 hour(3600 sec)
+  time_t expiration_time = 3600;
+  EXPECT_CALL(*cache, Get("hrn:here:data::olp-here-test:here-optimized-map-for-"
+                          "visualization-2::query::v1::api",
+                          _))
+      .Times(1)
+      .WillOnce(Return(boost::any()));
+  EXPECT_CALL(*cache, Put("hrn:here:data::olp-here-test:here-optimized-map-for-"
+                          "visualization-2::query::v1::api",
+                          _, _, expiration_time))
+      .Times(1)
+      .WillOnce(Return(true));
+  EXPECT_CALL(*cache, Get("hrn:here:data::olp-here-test:here-optimized-map-for-"
+                          "visualization-2::blob::v1::api",
+                          _))
+      .Times(1)
+      .WillOnce(Return(boost::any()));
+  EXPECT_CALL(*cache, Put("hrn:here:data::olp-here-test:here-optimized-map-for-"
+                          "visualization-2::blob::v1::api",
+                          _, _, expiration_time))
+      .Times(1)
+      .WillOnce(Return(true));
+
+  EXPECT_CALL(*cache, Get("hrn:here:data::olp-here-test:here-optimized-map-for-"
+                          "visualization-2::testlayer::269::4::partition",
+                          _))
+      .Times(1)
+      .WillOnce(Return(boost::any()));
+  EXPECT_CALL(*cache, Put("hrn:here:data::olp-here-test:here-optimized-map-for-"
+                          "visualization-2::testlayer::269::4::partition",
+                          _, _, _))
+      .Times(1)
+      .WillOnce(Return(true));
+
+  EXPECT_CALL(
+      *cache,
+      Get("hrn:here:data::olp-here-test:here-optimized-map-for-visualization-2:"
+          ":testlayer::4eed6ed1-0d32-43b9-ae79-043cb4256432::Data"))
+      .Times(1)
+      .WillOnce(Return(nullptr));
+  EXPECT_CALL(
+      *cache,
+      Put("hrn:here:data::olp-here-test:here-optimized-map-for-visualization-2:"
+          ":testlayer::4eed6ed1-0d32-43b9-ae79-043cb4256432::Data",
+          _, _))
+      .Times(1)
+      .WillOnce(Return(true));
+
+  auto request = olp::dataservice::read::DataRequest().WithPartitionId("269").WithFetchOption(OnlineIfNotFound);
+  auto future = client.GetData(request);
+
+  auto data_response = future.GetFuture().get();
+
+  ASSERT_TRUE(data_response.IsSuccessful())
+      << ApiErrorToString(data_response.GetError());
+  ASSERT_LT(0, data_response.GetResult()->size());
+  std::string data_string(data_response.GetResult()->begin(),
+                          data_response.GetResult()->end());
+  ASSERT_EQ("DT_2_0031", data_string);
+
+}
+
 }  // namespace