public void CanNotGetItemAfterExpiration()
{
TimedEventMock timedEventMock = null;
SystemClockMock clock = new SystemClockMock();
TimerFactoryMock timerFactory = new TimerFactoryMock(
timedEventMockFactory: (interval, runOnce, action) => {
TimedEventMock result = new TimedEventMock(interval, runOnce, action);
timedEventMock = result;
return(result);
},
timerMockFactory: null
);
const string key = "test_key";
const string value = "test_value";
clock.UtcNow = DateTime.Now;
TimeSpan expiration = TimeSpan.FromHours(1);
using (InMemoryCache <string> cache = new InMemoryCache <string>(clock, timerFactory)) {
cache.Set(key, value, expiration);
clock.UtcNow += expiration + TimeSpan.FromSeconds(5);
timedEventMock.Tick();
Assert.IsFalse(cache.HasItemWithKey(key), $"Cache contains entry with key '{key}'.");
Assert.ThrowsException <KeyNotFoundException>(() => cache.Get(key));
}
}
public void CanGetItemBeforeExpiration()
{
TimedEventMock timedEventMock = null;
SystemClockMock clock = new SystemClockMock();
TimerFactoryMock timerFactory = new TimerFactoryMock(
timedEventMockFactory: (interval, runOnce, action) => {
TimedEventMock result = new TimedEventMock(interval, runOnce, action);
timedEventMock = result;
return(result);
},
timerMockFactory: null
);
const string key = "test_key";
const string value = "test_value";
clock.UtcNow = DateTime.Now;
TimeSpan expiration = TimeSpan.FromHours(1);
using (InMemoryCache <string> cache = new InMemoryCache <string>(clock, timerFactory)) {
cache.Set(key, value, expiration);
clock.UtcNow += expiration - TimeSpan.FromMinutes(30);
timedEventMock.Tick();
Assert.IsTrue(cache.HasItemWithKey(key), $"Cache does not contain entry with key '{key}'.");
string actual = cache.Get(key);
Assert.AreEqual(value, actual);
}
}
public void CanSetMultipleItems()
{
SystemClockMock clock = new SystemClockMock();
TimerFactoryMock timerFactory = new TimerFactoryMock(
timedEventMockFactory: (x, y, z) => new EmptyDisposable(),
timerMockFactory: null
);
Dictionary <string, string> values = new Dictionary <string, string>()
{
["key1"] = "value1",
["key2"] = "value2"
};
using (InMemoryCache <string> cache = new InMemoryCache <string>(clock, timerFactory)) {
foreach (var item in values)
{
cache.Set(item.Key, item.Value, TimeSpan.FromTicks(1));
}
foreach (var item in values)
{
Assert.IsTrue(cache.HasItemWithKey(item.Key), $"Cache does not contain entry with key '{item.Key}'.");
Assert.AreEqual(item.Value, cache.Get(item.Key));
}
}
}
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 void CanSetItem()
{
SystemClockMock clock = new SystemClockMock();
TimerFactoryMock timerFactory = new TimerFactoryMock(
timedEventMockFactory: (x, y, z) => new EmptyDisposable(),
timerMockFactory: null
);
const string key = "test_key";
const string value = "test_value";
using (InMemoryCache <string> cache = new InMemoryCache <string>(clock, timerFactory)) {
cache.Set(key, value, TimeSpan.FromTicks(1));
Assert.IsTrue(cache.HasItemWithKey(key), $"Cache does not contain entry with key '{key}'.");
}
}
public void CanGetItem()
{
SystemClockMock clock = new SystemClockMock();
TimerFactoryMock timerFactory = new TimerFactoryMock(
timedEventMockFactory: (x, y, z) => new EmptyDisposable(),
timerMockFactory: null
);
const string key = "test_key";
const string value = "test_value";
using (InMemoryCache <string> cache = new InMemoryCache <string>(clock, timerFactory)) {
cache.Set(key, value, TimeSpan.FromTicks(1));
string actual = cache.Get(key);
Assert.AreEqual(value, actual);
}
}
public void CanInvokeExpirationMethodWhenItemExpires()
{
TimedEventMock timedEventMock = null;
SystemClockMock clock = new SystemClockMock();
TimerFactoryMock timerFactory = new TimerFactoryMock(
timedEventMockFactory: (interval, runOnce, action) => {
TimedEventMock result = new TimedEventMock(interval, runOnce, action);
timedEventMock = result;
return(result);
},
timerMockFactory: null
);
const string key = "test_key";
const string value = "test_value";
clock.UtcNow = DateTime.Now;
TimeSpan expiration = TimeSpan.FromHours(1);
bool expirationMethodInvoked = false;
bool expirationEventIsFiredForItem = false;
using (InMemoryCache <string> cache = new InMemoryCache <string>(clock, timerFactory)) {
cache.TtlExpired += (o, expiredValue) => {
if (expiredValue == value)
{
expirationEventIsFiredForItem = true;
}
};
cache.Set(key, value, expiration, (x) => { expirationMethodInvoked = true; });
clock.UtcNow += expiration + TimeSpan.FromSeconds(5);
timedEventMock.Tick();
Assert.IsTrue(expirationEventIsFiredForItem, $"{nameof(cache.TtlExpired)} is not fired for the expired item.");
Assert.IsTrue(expirationMethodInvoked, "The method set to be execute on expiration of the item has not invoked.");
}
}
public void CanDisposeProperly()
{
TimedEventMock timedEventMock = null;
SystemClockMock clock = new SystemClockMock();
TimerFactoryMock timerFactory = new TimerFactoryMock(
timedEventMockFactory: (interval, runOnce, action) => {
TimedEventMock result = new TimedEventMock(interval, runOnce, action);
timedEventMock = result;
return(result);
},
timerMockFactory: null
);
using (InMemoryCache <string> cache = new InMemoryCache <string>(clock, timerFactory)) {
//do nothing here
}
Assert.IsTrue(timedEventMock.DisposeInvoked, $"Dispose method is not invoked on {nameof(timedEventMock)}.");
}
public UnitTestContext(AuthenticationScheme authenticationScheme, Action <CertificateAuthenticationOptions> certificateAuthenticationOptionsConfigurer, HttpContextMock httpContext, LoggerFactoryMock loggerFactory, SystemClockMock systemClock, UrlEncoder urlEncoder)
{
this.AuthenticationScheme = authenticationScheme ?? throw new ArgumentNullException(nameof(authenticationScheme));
this.CertificateAuthenticationOptionsMonitor = new OptionsMonitorMock <CertificateAuthenticationOptions>(certificateAuthenticationOptionsConfigurer);
this.HttpContext = httpContext ?? throw new ArgumentNullException(nameof(httpContext));
this.LoggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
this.SystemClock = systemClock ?? throw new ArgumentNullException(nameof(systemClock));
this.UrlEncoder = urlEncoder ?? throw new ArgumentNullException(nameof(urlEncoder));
}
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);
}
