Skip internal keys' lookup in LRU

for the DefaultCache.

Relates-to: DATASDK-71
Signed-off-by: sopov <[email protected]>

Author: asopov-here

olp-cpp-sdk-core/src/cache/DefaultCacheImpl.cpp

@@ -881,7 +881,7 @@ OperationOutcomeEmpty DefaultCacheImpl::GetFromDiskCache(
 
     if (expiry > 0 || protected_keys_.IsProtected(key)) {
       // Entry didn't expire yet, we can still use it
-      if (!PromoteKeyLru(key)) {
+      if (!IsInternalKey(key) && !PromoteKeyLru(key)) {
         // If not found in LRU or not protected no need to look in disk cache
         // either.
         OLP_SDK_LOG_DEBUG_F(kLogTag,

olp-cpp-sdk-core/tests/cache/DefaultCacheImplTest.cpp

@@ -990,6 +990,79 @@ TEST_F(DefaultCacheImplTest, LruCacheEvictionWithProtected) {
   }
 }
 
+// SCOPED_TRACE("Expiry protected cache");
+// const std::string key1{"somekey1"};
+// const std::string key2{"somekey2"};
+// const std::string data_string{"this is key's data"};
+// constexpr auto expiry = 2;
+// std::vector<unsigned char> binary_data = {1, 2, 3};
+// const auto data_ptr =
+//     std::make_shared<std::vector<unsigned char>>(binary_data);
+//
+// cache::CacheSettings settings1;
+// settings1.disk_path_mutable = cache_path_;
+// DefaultCacheImplHelper cache1(settings1);
+// cache1.Open();
+// cache1.Clear();
+//
+// cache1.Put(key1, data_ptr, expiry);
+// cache1.Put(key2, data_string, [=]() { return data_string; }, expiry);
+// cache1.Close();
+//
+// cache::CacheSettings settings2;
+// settings2.disk_path_protected = cache_path_;
+// DefaultCacheImplHelper cache2(settings2);
+// cache2.Open();
+//
+// const auto value = cache2.Get(key1);
+// const auto value2 =
+//     cache2.Get(key2, [](const std::string& value) { return value; });
+//
+// EXPECT_FALSE(value.get() == nullptr);
+// EXPECT_EQ(value2.type(), typeid(std::string));
+// auto str = boost::any_cast<std::string>(value2);
+// EXPECT_EQ(str, data_string);
+//
+// std::this_thread::sleep_for(std::chrono::seconds(3));
+//
+// EXPECT_TRUE(cache2.Get(key1).get() == nullptr);
+// EXPECT_TRUE(
+//     cache2.Get(key2, [](const std::string& value) { return value;
+//     }).empty());
+// cache2.Close();
+
+TEST_F(DefaultCacheImplTest, InternalKeysBypassLru) {
+  {
+    SCOPED_TRACE("Protect and release keys, which suppose to be evicted");
+
+    const auto internal_key{"internal::protected::protected_data"};
+    cache::CacheSettings settings;
+    settings.disk_path_mutable = cache_path_;
+    settings.max_disk_storage = 2u * 1024u * 1024u;
+    {
+      DefaultCacheImplHelper cache(settings);
+      ASSERT_EQ(olp::cache::DefaultCache::Success, cache.Open());
+      cache.Clear();
+      const std::string key{"somekey"};
+      std::string data_string{"this is key's data"};
+
+      constexpr auto expiry = 2;
+      EXPECT_TRUE(cache.Put(key, data_string,
+                            [data_string]() { return data_string; }, expiry));
+      ASSERT_TRUE(cache.Protect({key}));
+    }
+
+    settings.disk_path_mutable = cache_path_;
+    settings.disk_path_protected.reset();
+
+    DefaultCacheImplHelper cache(settings);
+    ASSERT_TRUE(cache.Open());
+    // no keys was evicted
+    EXPECT_TRUE(cache.Get(internal_key));
+    cache.Clear();
+  }
+}
+
 TEST_F(DefaultCacheImplTest, ReadOnlyPartitionForProtectedCache) {
   SCOPED_TRACE("Read only partition protected cache");
   const std::string key{"somekey"};