public async Task RemoveExpiredCacheEntriesAsync_Test() { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); await using (var serviceProvider = await this.CreateServiceProviderAsync()) { // Prepare await using (var sqliteCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <SqliteCacheContext> >().CreateDbContext()) { for (var i = 0; i < 10; i++) { sqliteCacheContext.Cache.Add(new CacheEntry <DateTime> { ExpiresAtTime = now.AddYears(i).UtcDateTime, Id = i.ToString(CultureInfo.InvariantCulture), Value = new byte[i] }); } Assert.AreEqual(10, await sqliteCacheContext.SaveChangesAsync()); } now = now.AddYears(4).AddMonths(6); serviceProvider.SetTime(now); var sqliteCache = (SqliteCache)serviceProvider.GetRequiredService <IDistributedCache>(); Assert.AreEqual(5, await sqliteCache.RemoveExpiredCacheEntriesAsync()); await using (var sqliteCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <SqliteCacheContext> >().CreateDbContext()) { Assert.AreEqual(5, await sqliteCacheContext.Cache.CountAsync()); Assert.AreEqual(5, await sqliteCacheContext.Cache.CountAsync(cacheEntry => cacheEntry.ExpiresAtTime > now.UtcDateTime)); } } }
public async Task SetAsync_Test() { const string key = "Key"; await using (var serviceProvider = await this.CreateServiceProviderAsync()) { serviceProvider.SetTime(await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000)); var sqliteCache = (SqliteCache)serviceProvider.GetRequiredService <IDistributedCache>(); await sqliteCache.SetAsync(key, Array.Empty <byte>()); await using (var sqliteCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <SqliteCacheContext> >().CreateDbContext()) { Assert.AreEqual(1, await sqliteCacheContext.Cache.CountAsync()); var cacheEntry = await sqliteCacheContext.Cache.FindAsync(key); Assert.IsNull(cacheEntry.AbsoluteExpiration); Assert.AreEqual(await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000, minute: 20), cacheEntry.ExpiresAtTime); Assert.AreEqual(key, cacheEntry.Id); Assert.AreEqual(Convert.ToInt64(TimeSpan.FromMinutes(20).TotalSeconds), cacheEntry.SlidingExpirationInSeconds); Assert.IsTrue(Array.Empty <byte>().SequenceEqual(cacheEntry.Value)); } } }
public async Task GetAsync_Test() { const string key = "Key"; await using (var serviceProvider = await this.CreateServiceProviderAsync()) { var sqliteCache = (SqliteCache)serviceProvider.GetRequiredService <IDistributedCache>(); var value = await sqliteCache.GetAsync(key); Assert.IsNull(value); await sqliteCache.SetAsync(key, Array.Empty <byte>()); value = await sqliteCache.GetAsync(key); Assert.IsNotNull(value); var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); serviceProvider.SetTime(now); await sqliteCache.SetAsync(key, Array.Empty <byte>(), new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromSeconds(1) }); serviceProvider.SetTime(now.AddSeconds(2)); value = await sqliteCache.GetAsync(key); Assert.IsNull(value); } }
public async Task RefreshAsync_Test() { const string key = "Key"; await using (var serviceProvider = await this.CreateServiceProviderAsync()) { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); serviceProvider.SetTime(now); var sqliteCache = (SqliteCache)serviceProvider.GetRequiredService <IDistributedCache>(); await sqliteCache.SetAsync(key, Array.Empty <byte>(), new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromSeconds(1) }); await using (var sqliteCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <SqliteCacheContext> >().CreateDbContext()) { var cacheEntry = await sqliteCacheContext.Cache.FindAsync(key); Assert.AreEqual(now.UtcDateTime.AddSeconds(1), cacheEntry.ExpiresAtTime); } serviceProvider.SetTime(now.AddSeconds(1)); await sqliteCache.RefreshAsync(key); await using (var sqliteCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <SqliteCacheContext> >().CreateDbContext()) { var cacheEntry = await sqliteCacheContext.Cache.FindAsync(key); Assert.AreEqual(now.UtcDateTime.AddSeconds(2), cacheEntry.ExpiresAtTime); } } }
public async Task Refresh_Test() { const string key = "Key"; await using (var serviceProvider = await this.CreateServiceProviderAsync()) { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); serviceProvider.SetTime(now); var dateTimeOffsetContextCache = (DateTimeOffsetCacheMock)serviceProvider.GetRequiredService <IDistributedCache>(); // ReSharper disable All dateTimeOffsetContextCache.Set(key, Array.Empty <byte>(), new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromSeconds(1) }); using (var dateTimeOffsetCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <DateTimeOffsetCacheContext> >().CreateDbContext()) { var cacheEntry = dateTimeOffsetCacheContext.Cache.Find(key); Assert.AreEqual(now.AddSeconds(1), cacheEntry.ExpiresAtTime); } serviceProvider.SetTime(now.AddSeconds(1)); dateTimeOffsetContextCache.Refresh(key); using (var dateTimeOffsetCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <DateTimeOffsetCacheContext> >().CreateDbContext()) { var cacheEntry = dateTimeOffsetCacheContext.Cache.Find(key); Assert.AreEqual(now.AddSeconds(2), cacheEntry.ExpiresAtTime); } // ReSharper restore All } }
public async Task Get_Test() { const string key = "Key"; await using (var serviceProvider = await this.CreateServiceProviderAsync()) { // ReSharper disable MethodHasAsyncOverload var dateTimeOffsetContextCache = (DateTimeOffsetCacheMock)serviceProvider.GetRequiredService <IDistributedCache>(); var value = dateTimeOffsetContextCache.Get(key); Assert.IsNull(value); dateTimeOffsetContextCache.Set(key, Array.Empty <byte>()); value = dateTimeOffsetContextCache.Get(key); Assert.IsNotNull(value); var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); serviceProvider.SetTime(now); dateTimeOffsetContextCache.Set(key, Array.Empty <byte>(), new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromSeconds(1) }); serviceProvider.SetTime(now.AddSeconds(2)); value = dateTimeOffsetContextCache.Get(key); Assert.IsNull(value); // ReSharper restore MethodHasAsyncOverload } }
public async Task Set_Test() { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); await using (var serviceProvider = await this.CreateServiceProviderAsync(now)) { var sqlServerCacheOptions = serviceProvider.GetRequiredService <IOptions <SqlServerCacheOptions> >().Value; Assert.AreEqual(TimeSpan.FromMinutes(20), sqlServerCacheOptions.DefaultSlidingExpiration); Assert.IsNull(sqlServerCacheOptions.ExpiredItemsDeletionInterval); var sqlServerCache = (SqlServerCache)serviceProvider.GetRequiredService <IDistributedCache>(); // ReSharper disable MethodHasAsyncOverload sqlServerCache.Set("1", Array.Empty <byte>(), new DistributedCacheEntryOptions()); // ReSharper restore MethodHasAsyncOverload using (var scope = serviceProvider.CreateScope()) { var sqlServerCacheContext = scope.ServiceProvider.GetRequiredService <SqlServerCacheContext>(); Assert.AreEqual(1, await sqlServerCacheContext.Cache.CountAsync()); var cacheEntry = await sqlServerCacheContext.Cache.FindAsync("1"); Assert.IsNotNull(cacheEntry); Assert.IsNull(cacheEntry.AbsoluteExpiration); Assert.AreEqual(now.Add(sqlServerCacheOptions.DefaultSlidingExpiration), cacheEntry.ExpiresAtTime); Assert.AreEqual("1", cacheEntry.Id); Assert.AreEqual((uint)sqlServerCacheOptions.DefaultSlidingExpiration.TotalSeconds, cacheEntry.SlidingExpirationInSeconds); Assert.IsTrue(Array.Empty <byte>().SequenceEqual(cacheEntry.Value)); } } }
public async Task GetRefreshedExpiration_Test() { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); var systemClock = new SystemClockMock { UtcNow = now }; var contextCache = await this.CreateContextCacheAsync(systemClock : systemClock); var initialExpires = now.AddSeconds(10); var cacheEntry = new CacheEntry <DateTimeOffset> { ExpiresAtTime = initialExpires }; Assert.AreEqual(initialExpires, contextCache.GetRefreshedExpiration(cacheEntry)); cacheEntry = new CacheEntry <DateTimeOffset> { ExpiresAtTime = initialExpires, SlidingExpirationInSeconds = 60 }; Assert.AreEqual(now.AddSeconds(60), contextCache.GetRefreshedExpiration(cacheEntry)); cacheEntry = new CacheEntry <DateTimeOffset> { AbsoluteExpiration = now.AddHours(5), ExpiresAtTime = initialExpires }; Assert.AreEqual(initialExpires, contextCache.GetRefreshedExpiration(cacheEntry)); cacheEntry = new CacheEntry <DateTimeOffset> { AbsoluteExpiration = now.AddHours(5), ExpiresAtTime = initialExpires, SlidingExpirationInSeconds = 60 }; Assert.AreEqual(now.AddSeconds(60), contextCache.GetRefreshedExpiration(cacheEntry)); cacheEntry = new CacheEntry <DateTimeOffset> { AbsoluteExpiration = now.AddSeconds(40), ExpiresAtTime = initialExpires, SlidingExpirationInSeconds = 60 }; Assert.AreEqual(now.AddSeconds(40), contextCache.GetRefreshedExpiration(cacheEntry)); }
public async Task CleanupIfNecessary_Test() { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); await using (var serviceProvider = await this.CreateServiceProviderAsync()) { // Prepare await using (var dateTimeOffsetCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <DateTimeOffsetCacheContext> >().CreateDbContext()) { for (var i = 0; i < 10; i++) { dateTimeOffsetCacheContext.Cache.Add(new CacheEntry <DateTimeOffset> { ExpiresAtTime = now.AddYears(i), Id = i.ToString(CultureInfo.InvariantCulture), Value = new byte[i] }); } Assert.AreEqual(10, await dateTimeOffsetCacheContext.SaveChangesAsync()); } now = now.AddYears(4).AddMonths(6); serviceProvider.SetTime(now); var dateTimeOffsetContextCache = (DateTimeOffsetCacheMock)serviceProvider.GetRequiredService <IDistributedCache>(); Assert.AreEqual(DateTimeOffset.MaxValue, dateTimeOffsetContextCache.LastCleanup); dateTimeOffsetContextCache.LastCleanup = DateTimeOffset.MinValue; dateTimeOffsetContextCache.CleanupIfNecessary(); Thread.Sleep(500); Assert.AreEqual(now, dateTimeOffsetContextCache.LastCleanup); await using (var dateTimeOffsetCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <DateTimeOffsetCacheContext> >().CreateDbContext()) { Assert.AreEqual(5, await dateTimeOffsetCacheContext.Cache.CountAsync()); Assert.AreEqual(5, await dateTimeOffsetCacheContext.Cache.CountAsync(cacheEntry => cacheEntry.ExpiresAtTime > now)); } } }
public async Task RemoveExpiredCacheEntries_Test() { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); await using (var serviceProvider = await this.CreateServiceProviderAsync()) { // Prepare await using (var dateTimeOffsetCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <DateTimeOffsetCacheContext> >().CreateDbContext()) { for (var i = 0; i < 10; i++) { dateTimeOffsetCacheContext.Cache.Add(new CacheEntry <DateTimeOffset> { ExpiresAtTime = now.AddYears(i), Id = i.ToString(CultureInfo.InvariantCulture), Value = new byte[i] }); } Assert.AreEqual(10, await dateTimeOffsetCacheContext.SaveChangesAsync()); } now = now.AddYears(4).AddMonths(6); serviceProvider.SetTime(now); var dateTimeOffsetContextCache = (DateTimeOffsetCacheMock)serviceProvider.GetRequiredService <IDistributedCache>(); // ReSharper disable MethodHasAsyncOverload Assert.AreEqual(5, dateTimeOffsetContextCache.RemoveExpiredCacheEntries()); // ReSharper restore MethodHasAsyncOverload await using (var dateTimeOffsetCacheContext = serviceProvider.GetRequiredService <IDbContextFactory <DateTimeOffsetCacheContext> >().CreateDbContext()) { Assert.AreEqual(5, await dateTimeOffsetCacheContext.Cache.CountAsync()); Assert.AreEqual(5, await dateTimeOffsetCacheContext.Cache.CountAsync(cacheEntry => cacheEntry.ExpiresAtTime > now)); } } }
public async Task GetExpirationInformation_Test() { var now = await DateTimeOffsetHelper.CreateDateTimeOffsetAsync(2000); var systemClock = new SystemClockMock { UtcNow = now }; var contextCache = await this.CreateContextCacheAsync(systemClock : systemClock); var expirationInformation = contextCache.GetExpirationInformation(new DistributedCacheEntryOptions()); Assert.IsNull(expirationInformation.AbsoluteExpiration); Assert.AreEqual(now.AddMinutes(20), expirationInformation.Expires); Assert.IsNotNull(expirationInformation.SlidingExpirationInSeconds); Assert.AreEqual(20 * 60, expirationInformation.SlidingExpirationInSeconds.Value); var absoluteExpiration = now.AddDays(2); var options = new DistributedCacheEntryOptions { AbsoluteExpiration = absoluteExpiration }; expirationInformation = contextCache.GetExpirationInformation(options); Assert.IsNotNull(expirationInformation.AbsoluteExpiration); Assert.AreEqual(absoluteExpiration, expirationInformation.AbsoluteExpiration.Value); Assert.AreEqual(absoluteExpiration, expirationInformation.Expires); Assert.IsNull(expirationInformation.SlidingExpirationInSeconds); absoluteExpiration = now.AddDays(5); var absoluteExpirationRelativeToNow = TimeSpan.FromDays(5); options = new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = absoluteExpirationRelativeToNow }; expirationInformation = contextCache.GetExpirationInformation(options); Assert.IsNotNull(expirationInformation.AbsoluteExpiration); Assert.AreEqual(absoluteExpiration, expirationInformation.AbsoluteExpiration.Value); Assert.AreEqual(absoluteExpiration, expirationInformation.Expires); Assert.IsNull(expirationInformation.SlidingExpirationInSeconds); options = new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromMinutes(50) }; expirationInformation = contextCache.GetExpirationInformation(options); Assert.IsNull(expirationInformation.AbsoluteExpiration); Assert.AreEqual(now.AddMinutes(50), expirationInformation.Expires); Assert.IsNotNull(expirationInformation.SlidingExpirationInSeconds); Assert.AreEqual(50 * 60, expirationInformation.SlidingExpirationInSeconds.Value); options = new DistributedCacheEntryOptions { AbsoluteExpiration = now.AddDays(5), AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(15), SlidingExpiration = TimeSpan.FromMinutes(40) }; expirationInformation = contextCache.GetExpirationInformation(options); Assert.IsNotNull(expirationInformation.AbsoluteExpiration); Assert.AreEqual(now.AddDays(15), expirationInformation.AbsoluteExpiration.Value); Assert.AreEqual(now.AddMinutes(40), expirationInformation.Expires); Assert.IsNotNull(expirationInformation.SlidingExpirationInSeconds); Assert.AreEqual(40 * 60, expirationInformation.SlidingExpirationInSeconds.Value); options = new DistributedCacheEntryOptions { AbsoluteExpiration = now.AddDays(5), SlidingExpiration = TimeSpan.FromMinutes(40) }; expirationInformation = contextCache.GetExpirationInformation(options); Assert.IsNotNull(expirationInformation.AbsoluteExpiration); Assert.AreEqual(now.AddDays(5), expirationInformation.AbsoluteExpiration.Value); Assert.AreEqual(now.AddMinutes(40), expirationInformation.Expires); Assert.IsNotNull(expirationInformation.SlidingExpirationInSeconds); Assert.AreEqual(40 * 60, expirationInformation.SlidingExpirationInSeconds.Value); options = new DistributedCacheEntryOptions { AbsoluteExpiration = now.AddDays(5), AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(15) }; expirationInformation = contextCache.GetExpirationInformation(options); Assert.IsNotNull(expirationInformation.AbsoluteExpiration); Assert.AreEqual(now.AddDays(15), expirationInformation.AbsoluteExpiration.Value); Assert.AreEqual(now.AddDays(15), expirationInformation.Expires); Assert.IsNull(expirationInformation.SlidingExpirationInSeconds); }