feat multi-index-lru: allow time mocking and make the tests more reliable

Tests: протестировано CI
commit_hash:243ec522bacd2e97b356205791d2addc8b8fcfcc

Author: apolukhin

libraries/multi-index-lru/include/userver/multi-index-lru/expirable_container.hpp

@@ -7,6 +7,7 @@
 #include "impl/mpl_helpers.hpp"
 
 #include <userver/utils/assert.hpp>
+#include <userver/utils/datetime.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
@@ -28,10 +29,11 @@ class ExpirableContainer {
 
     template <typename... Args>
     auto emplace(Args&&... args) {
-        auto result = container_.emplace(std::forward<Args>(args)...);
+        const auto now = utils::datetime::SteadyClock::now();
+        auto result = container_.emplace(now, std::forward<Args>(args)...);
 
         if (!result.second) {
-            result.first->last_accessed = std::chrono::steady_clock::now();
+            result.first->last_accessed = now;
         }
 
         return result;
@@ -43,7 +45,7 @@ class ExpirableContainer {
 
     template <typename Tag, typename Key>
     auto find(const Key& key) {
-        const auto now = std::chrono::steady_clock::now();
+        const auto now = utils::datetime::SteadyClock::now();
         auto it = container_.template find<Tag, Key>(key);
 
         if (it != container_.template end<Tag>()) {
@@ -66,7 +68,7 @@ class ExpirableContainer {
 
     template <typename Tag, typename Key>
     auto equal_range(const Key& key) {
-        const auto now = std::chrono::steady_clock::now();
+        const auto now = utils::datetime::SteadyClock::now();
         auto range = container_.template equal_range<Tag, Key>(key);
 
         auto it = range.first;
@@ -139,7 +141,7 @@ class ExpirableContainer {
 
     /// @brief Removes all expired items from container
     void cleanup_expired() {
-        const auto now = std::chrono::steady_clock::now();
+        const auto now = utils::datetime::SteadyClock::now();
 
         while (!container_.empty()) {
             const auto it = container_.find_last_accessed_no_update();

libraries/multi-index-lru/include/userver/multi-index-lru/impl/mpl_helpers.hpp

@@ -58,14 +58,14 @@ struct TimestampedValue {
 
     TimestampedValue() = default;
 
-    explicit TimestampedValue(const Value& val)
+    TimestampedValue(std::chrono::steady_clock::time_point now, const Value& val)
         : value(val),
-          last_accessed(std::chrono::steady_clock::now())
+          last_accessed(now)
     {}
 
-    explicit TimestampedValue(Value&& val)
+    TimestampedValue(std::chrono::steady_clock::time_point now, Value&& val)
         : value(std::move(val)),
-          last_accessed(std::chrono::steady_clock::now())
+          last_accessed(now)
     {}
 
     operator Value&() noexcept { return value; }

libraries/multi-index-lru/src/expirable_container_test.cpp

@@ -3,6 +3,7 @@
 #include <userver/multi-index-lru/expirable_container.hpp>
 #include <userver/utest/utest.hpp>
 #include <userver/utils/async.hpp>
+#include <userver/utils/mock_now.hpp>
 
 #include <mutex>
 #include <string>
@@ -109,6 +110,7 @@ UTEST_F(ExpirableUsersTest, LRUEviction) {
 
 UTEST_F(ExpirableUsersTest, TTLExpiration) {
     using namespace std::chrono_literals;
+    utils::datetime::MockNowSet(std::chrono::system_clock::now());
 
     UserCacheExpirable cache(100, 100ms);  // Very short TTL for testing
 
@@ -121,7 +123,7 @@ UTEST_F(ExpirableUsersTest, TTLExpiration) {
     EXPECT_EQ(cache.size(), 2);
 
     // Wait for TTL to expire
-    engine::SleepFor(150ms);
+    utils::datetime::MockSleep(150ms);
 
     EXPECT_EQ(cache.find<IdTag>(1), cache.end<IdTag>());
     EXPECT_EQ(cache.find<IdTag>(2), cache.end<IdTag>());
@@ -130,23 +132,24 @@ UTEST_F(ExpirableUsersTest, TTLExpiration) {
 
 UTEST_F(ExpirableUsersTest, TTLRefreshOnAccess) {
     using namespace std::chrono_literals;
+    utils::datetime::MockNowSet(std::chrono::system_clock::now());
 
     UserCacheExpirable cache(100, 190ms);
 
     cache.insert(User{1, "alice@test.com", "Alice"});
 
     // Wait a bit but not enough to expire
-    engine::SleepFor(99ms);
+    utils::datetime::MockSleep(99ms);
 
     // Access via find should refresh TTL
     EXPECT_NE(cache.find<IdTag>(1), cache.end<IdTag>());
 
     // Wait again - should still be alive due to refresh
-    engine::SleepFor(99ms);
+    utils::datetime::MockSleep(99ms);
     EXPECT_NE(cache.find<IdTag>(1), cache.end<IdTag>());
 
     // Wait for full TTL from last access
-    engine::SleepFor(200ms);
+    utils::datetime::MockSleep(200ms);
     EXPECT_EQ(cache.find<IdTag>(1), cache.end<IdTag>());
 }
 
@@ -248,14 +251,15 @@ UTEST_F(ExpirableUsersTest, Clear) {
 
 UTEST_F(ExpirableUsersTest, CleanupExpired) {
     using namespace std::chrono_literals;
+    utils::datetime::MockNowSet(std::chrono::system_clock::now());
 
     UserCacheExpirable cache(5, 100ms);
 
     cache.insert(User{1, "alice@test.com", "Alice"});
     cache.insert(User{2, "bob@test.com", "Bob"});
 
     // Wait for TTL to expire
-    engine::SleepFor(150ms);
+    utils::datetime::MockSleep(150ms);
 
     // cleanup_expired should remove expired items
     cache.cleanup_expired();