LRUPersistentCacheTest.cpp File Reference

#include <chrono>
#include <thread>
#include <vector>
#include <folly/Memory.h>
#include <folly/executors/ManualExecutor.h>
#include <folly/futures/Future.h>
#include <folly/portability/GMock.h>
#include <folly/portability/GTest.h>
#include <folly/synchronization/Baton.h>
#include <wangle/client/persistence/LRUPersistentCache.h>
#include <wangle/client/persistence/SharedMutexCacheLockGuard.h>

Go to the source code of this file.

Classes
class	MockPersistenceLayer
class	LRUPersistentCacheTest< MutexT >

Typedefs
using	TestPersistenceLayer = CachePersistence< string, string >
using	MutexTypes = ::testing::Types< std::mutex, folly::SharedMutex >

Functions
	TYPED_TEST_CASE (LRUPersistentCacheTest, MutexTypes)
template<typename T >
static shared_ptr< LRUPersistentCache< string, string, T > >	createCache (size_t capacity, uint32_t syncMillis, std::unique_ptr< TestPersistenceLayer > persistence=nullptr)
template<typename T >
static shared_ptr< LRUPersistentCache< string, string, T > >	createCacheWithExecutor (std::shared_ptr< folly::Executor > executor, std::unique_ptr< TestPersistenceLayer > persistence, std::chrono::milliseconds syncInterval, int retryLimit)
	TYPED_TEST (LRUPersistentCacheTest, NullPersistence)
	MATCHER_P (DynSize, n,"")
	TYPED_TEST (LRUPersistentCacheTest, SettingPersistence)
	TYPED_TEST (LRUPersistentCacheTest, SyncOnDestroy)
	TYPED_TEST (LRUPersistentCacheTest, SetPersistenceMidPersist)
	TYPED_TEST (LRUPersistentCacheTest, PersistNotCalled)
	TYPED_TEST (LRUPersistentCacheTest, PersistentSetBeforeSyncer)
	TYPED_TEST (LRUPersistentCacheTest, ClearKeepPersist)
	TYPED_TEST (LRUPersistentCacheTest, ClearDontKeepPersist)
	TYPED_TEST (LRUPersistentCacheTest, ExecutorCacheDeallocBeforeAdd)
	TYPED_TEST (LRUPersistentCacheTest, ExecutorCacheRunTask)
	TYPED_TEST (LRUPersistentCacheTest, ExecutorCacheRunTaskInline)
	TYPED_TEST (LRUPersistentCacheTest, ExecutorCacheRetries)
	TYPED_TEST (LRUPersistentCacheTest, ExecutorCacheSchduledAndDealloc)
	TYPED_TEST (LRUPersistentCacheTest, ExecutorCacheScheduleInterval)

Typedef Documentation

using MutexTypes = ::testing::Types<std::mutex, folly::SharedMutex>

Definition at line 36 of file LRUPersistentCacheTest.cpp.

using TestPersistenceLayer = CachePersistence<string, string>

Definition at line 34 of file LRUPersistentCacheTest.cpp.

Function Documentation

template<typename T >

static shared_ptr<LRUPersistentCache<string, string, T> > createCache ( size_t  capacity, uint32_t  syncMillis, std::unique_ptr< TestPersistenceLayer >  persistence = nullptr  )

static

Definition at line 40 of file LRUPersistentCacheTest.cpp.

References folly::gen::move.

                                                               {
  using TestCache = LRUPersistentCache<string, string, T>;
  return std::make_shared<TestCache>(
      capacity,
      std::chrono::milliseconds(syncMillis),
      3,
      std::move(persistence));
}

template<typename T >

static shared_ptr<LRUPersistentCache<string, string, T> > createCacheWithExecutor ( std::shared_ptr< folly::Executor >  executor, std::unique_ptr< TestPersistenceLayer >  persistence, std::chrono::milliseconds  syncInterval, int  retryLimit  )

static

Definition at line 54 of file LRUPersistentCacheTest.cpp.

References folly::gen::move.

                    {
  return std::make_shared<LRUPersistentCache<string, string, T>>(
      std::move(executor),
      10,
      syncInterval,
      retryLimit,
      std::move(persistence));
}

MATCHER_P	(	DynSize	,
		n	,
		""
	)

Definition at line 126 of file LRUPersistentCacheTest.cpp.

                          {
  return size_t(n) == arg.size();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		NullPersistence
	)

Definition at line 113 of file LRUPersistentCacheTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::makeFuture(), and val.

                                                    {
  // make sure things sync even without a persistence layer
  auto cache = createCache<TypeParam>(10, 1, nullptr);
  cache->put("k0", "v0");
  makeFuture().delayed(std::chrono::milliseconds(20)).thenValue(
    [cache](auto&&) {
      auto val = cache->get("k0");
      EXPECT_TRUE(val);
      EXPECT_EQ(*val, "v0");
      EXPECT_FALSE(cache->hasPendingUpdates());
    });
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		SettingPersistence
	)

Definition at line 130 of file LRUPersistentCacheTest.cpp.

References folly::dynamic::array(), folly::data(), EXPECT_CALL, folly::gen::move, testing::Return(), and folly::gen::seq().

                                                       {
  auto cache = createCache<TypeParam>(10, 10, nullptr);
  cache->put("k0", "v0");
  folly::dynamic data = dynamic::array(dynamic::array("k1", "v1"));
  InSequence seq;
  EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(data));
  EXPECT_CALL(*this->persistence, persist_(DynSize(2)))
    .Times(1)
    .WillOnce(Return(true));
  cache->setPersistence(std::move(this->persistence));
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		SyncOnDestroy
	)

Definition at line 144 of file LRUPersistentCacheTest.cpp.

References testing::_, EXPECT_CALL, folly::gen::move, and testing::Return().

                                                  {
  auto cache = createCache<TypeParam>(10, 10000, nullptr);
  cache->setSyncOnDestroy(true);
  auto persistence = this->persistence.get();
  cache->setPersistence(std::move(this->persistence));
  cache->put("k0", "v0");
  EXPECT_CALL(*persistence, persist_(_))
    .Times(1)
    .WillOnce(Return(true));
  cache.reset();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		SetPersistenceMidPersist
	)

Definition at line 156 of file LRUPersistentCacheTest.cpp.

References folly::dynamic::array(), EXPECT_CALL, MockPersistenceLayer::getLastPersistedVersionConcrete(), testing::Invoke(), folly::makeFuture(), folly::gen::move, ON_CALL, and testing::Return().

                                                             {
  // Setup a cache with no persistence layer
  // Add some items
  // Add a persistence layer, that during persist will call a function
  // to set a new persistence layer on the cache
  // Ensure that the new layer is called with the data
  auto cache = createCache<TypeParam>(10, 10, nullptr);
  cache->put("k0", "v0");
  cache->put("k1", "v1");

  EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(dynamic::array()));

  auto func = [cache](const folly::dynamic& /* kv */ ) {
    // The cache persistence that we'll set during a call to persist
    auto p2 = make_unique<MockPersistenceLayer>();
    ON_CALL(*p2, getLastPersistedVersion())
      .WillByDefault(
          Invoke(
            p2.get(),
            &MockPersistenceLayer::getLastPersistedVersionConcrete));
    EXPECT_CALL(*p2, load_())
      .Times(1)
      .WillOnce(Return(dynamic::array()));
    EXPECT_CALL(*p2, persist_(DynSize(2)))
      .Times(1)
      .WillOnce(Return(true));

    cache->setPersistence(std::move(p2));
    return true;
  };
  EXPECT_CALL(*this->persistence, persist_(DynSize(2)))
    .Times(1)
    .WillOnce(Invoke(func));

  cache->setPersistence(std::move(this->persistence));
  makeFuture().delayed(std::chrono::milliseconds(100)).get();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		PersistNotCalled
	)

Definition at line 196 of file LRUPersistentCacheTest.cpp.

References testing::_, folly::dynamic::array(), folly::data(), EXPECT_CALL, EXPECT_EQ, folly::gen::move, and testing::Return().

                                                     {
  folly::dynamic data = dynamic::array(dynamic::array("k1", "v1"));
  EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(data));
  EXPECT_CALL(*this->persistence, persist_(_))
    .Times(0)
    .WillOnce(Return(false));
  auto cache = createCache<TypeParam>(10, 10, std::move(this->persistence));
  EXPECT_EQ(cache->size(), 1);
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		PersistentSetBeforeSyncer
	)

Definition at line 208 of file LRUPersistentCacheTest.cpp.

References testing::AtLeast(), EXPECT_CALL, MockPersistenceLayer::getLastPersistedVersionConcrete(), testing::Invoke(), and folly::gen::move.

                                                              {
  EXPECT_CALL(*this->persistence, getLastPersistedVersion())
    .Times(AtLeast(1))
    .WillRepeatedly(
        Invoke(
          this->persistence.get(),
          &MockPersistenceLayer::getLastPersistedVersionConcrete));
  auto cache = createCache<TypeParam>(10, 10, std::move(this->persistence));
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ClearKeepPersist
	)

Definition at line 218 of file LRUPersistentCacheTest.cpp.

References EXPECT_CALL, and folly::gen::move.

                                                     {
  EXPECT_CALL(*this->persistence, clear()).Times(0);
  auto cache = createCache<TypeParam>(10, 10, std::move(this->persistence));
  cache->clear();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ClearDontKeepPersist
	)

Definition at line 224 of file LRUPersistentCacheTest.cpp.

References EXPECT_CALL, and folly::gen::move.

                                                         {
  EXPECT_CALL(*this->persistence, clear()).Times(1);
  auto cache = createCache<TypeParam>(10, 10, std::move(this->persistence));
  cache->clear(true);
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ExecutorCacheDeallocBeforeAdd
	)

Definition at line 230 of file LRUPersistentCacheTest.cpp.

References folly::gen::move.

                                                                  {
  auto cache = createCacheWithExecutor<TypeParam>(
      this->manualExecutor,
      std::move(this->persistence),
      std::chrono::milliseconds::zero(),
      1);
  cache.reset();
  // Nothing should happen here
  this->manualExecutor->drain();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ExecutorCacheRunTask
	)

Definition at line 241 of file LRUPersistentCacheTest.cpp.

References folly::dynamic::array(), folly::data(), EXPECT_CALL, MockPersistenceLayer::getLastPersistedVersionConcrete(), testing::Invoke(), folly::gen::move, and testing::Return().

                                                         {
  folly::dynamic data = dynamic::array(dynamic::array("k1", "v1"));
  EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(data));
  auto rawPersistence = this->persistence.get();
  auto cache = createCacheWithExecutor<TypeParam>(
      this->manualExecutor,
      std::move(this->persistence),
      std::chrono::milliseconds::zero(),
      1);
  cache->put("k0", "v0");
  EXPECT_CALL(*rawPersistence, getLastPersistedVersion())
      .Times(1)
      .WillOnce(Invoke(
          rawPersistence,
          &MockPersistenceLayer::getLastPersistedVersionConcrete));
  EXPECT_CALL(*rawPersistence, persist_(DynSize(2)))
      .Times(1)
      .WillOnce(Return(true));
  this->manualExecutor->run();
  cache.reset();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ExecutorCacheRunTaskInline
	)

Definition at line 265 of file LRUPersistentCacheTest.cpp.

References folly::dynamic::array(), folly::data(), EXPECT_CALL, MockPersistenceLayer::getLastPersistedVersionConcrete(), testing::Invoke(), folly::gen::move, and testing::Return().

                                                               {
  folly::dynamic data = dynamic::array(dynamic::array("k1", "v1"));
  EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(data));
  auto rawPersistence = this->persistence.get();
  auto cache = createCacheWithExecutor<TypeParam>(
      this->inlineExecutor,
      std::move(this->persistence),
      std::chrono::milliseconds::zero(),
      1);
  EXPECT_CALL(*rawPersistence, getLastPersistedVersion())
      .Times(1)
      .WillOnce(Invoke(
          rawPersistence,
          &MockPersistenceLayer::getLastPersistedVersionConcrete));
  EXPECT_CALL(*rawPersistence, persist_(DynSize(2)))
      .Times(1)
      .WillOnce(Return(true));
  cache->put("k0", "v0");

  EXPECT_CALL(*rawPersistence, getLastPersistedVersion())
      .Times(1)
      .WillOnce(Invoke(
          rawPersistence,
          &MockPersistenceLayer::getLastPersistedVersionConcrete));
  EXPECT_CALL(*rawPersistence, persist_(DynSize(3)))
      .Times(1)
      .WillOnce(Return(true));
  cache->put("k2", "v2");
  cache.reset();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ExecutorCacheRetries
	)

Definition at line 298 of file LRUPersistentCacheTest.cpp.

References testing::_, folly::dynamic::array(), EXPECT_CALL, MockPersistenceLayer::getLastPersistedVersionConcrete(), testing::Invoke(), folly::gen::move, testing::Return(), and MockPersistenceLayer::setPersistedVersionConcrete().

                                                         {
  EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(dynamic::array()));
  auto rawPersistence = this->persistence.get();
  auto cache = createCacheWithExecutor<TypeParam>(
      this->manualExecutor,
      std::move(this->persistence),
      std::chrono::milliseconds::zero(),
      2);
  EXPECT_CALL(*rawPersistence, getLastPersistedVersion())
      .WillRepeatedly(Invoke(
          rawPersistence,
          &MockPersistenceLayer::getLastPersistedVersionConcrete));

  cache->put("k0", "v0");
  EXPECT_CALL(*rawPersistence, persist_(DynSize(1)))
      .Times(1)
      .WillOnce(Return(false));
  this->manualExecutor->run();

  cache->put("k1", "v1");
  EXPECT_CALL(*rawPersistence, persist_(DynSize(2)))
      .Times(1)
      .WillOnce(Return(false));
  // reached retry limit, so we will set a version anyway
  EXPECT_CALL(*rawPersistence, setPersistedVersion(_))
      .Times(1)
      .WillOnce(Invoke(
          rawPersistence, &MockPersistenceLayer::setPersistedVersionConcrete));
  this->manualExecutor->run();

  cache.reset();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ExecutorCacheSchduledAndDealloc
	)

Definition at line 333 of file LRUPersistentCacheTest.cpp.

References folly::dynamic::array(), folly::data(), EXPECT_CALL, folly::gen::move, and testing::Return().

                                                                    {
  folly::dynamic data = dynamic::array(dynamic::array("k1", "v1"));
  EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(data));
  auto cache = createCacheWithExecutor<TypeParam>(
      this->manualExecutor,
      std::move(this->persistence),
      std::chrono::milliseconds::zero(),
      1);
  cache->put("k0", "v0");
  cache->put("k2", "v2");

  // Kill cache first then try to run scheduled tasks. Nothing will run and no
  // one should crash.
  cache.reset();
  this->manualExecutor->drain();
}

TYPED_TEST	(	LRUPersistentCacheTest	,
		ExecutorCacheScheduleInterval
	)

Definition at line 352 of file LRUPersistentCacheTest.cpp.

References testing::_, folly::dynamic::array(), EXPECT_CALL, MockPersistenceLayer::getLastPersistedVersionConcrete(), testing::Invoke(), folly::gen::move, and testing::Return().

                                                                  {
 EXPECT_CALL(*this->persistence, load_())
    .Times(1)
    .WillOnce(Return(dynamic::array()));
  auto rawPersistence = this->persistence.get();
  auto cache = createCacheWithExecutor<TypeParam>(
      this->manualExecutor,
      std::move(this->persistence),
      std::chrono::milliseconds(60 * 60 * 1000),
      1);
  EXPECT_CALL(*rawPersistence, getLastPersistedVersion())
      .WillRepeatedly(Invoke(
          rawPersistence,
          &MockPersistenceLayer::getLastPersistedVersionConcrete));

  cache->put("k0", "v0");
  EXPECT_CALL(*rawPersistence, persist_(DynSize(1)))
      .Times(1)
      .WillOnce(Return(false));
  this->manualExecutor->run();

  // None of the following will trigger a run
  EXPECT_CALL(*rawPersistence, persist_(DynSize(2))).Times(0);
  EXPECT_CALL(*rawPersistence, setPersistedVersion(_)).Times(0);
  cache->put("k1", "v1");
  this->manualExecutor->run();
  cache.reset();
  this->manualExecutor->drain();
}

TYPED_TEST_CASE	(	LRUPersistentCacheTest	,
		MutexTypes
	)