public async Task RemoveAsync_FunctionWithoutParameters_ShouldBeRemoved()
{
var key = _distributedCacheService.GetKey(() => _testFunctions.FunctionWithoutParameters());
await _memoryDistributedCache.SetStringAsync(key, JsonConvert.SerializeObject(Value));
var beforeRemove = await _memoryDistributedCache.GetStringAsync(key);
await _distributedCacheService.RemoveAsync(() => _testFunctions.FunctionWithoutParameters());
var afterRemove = await _memoryDistributedCache.GetStringAsync(key);
beforeRemove.Should().NotBeNull();
afterRemove.Should().BeNull();
}
public async Task NewUserBeginsWatchingStream(bool ongoing)
{
string connectionId = Guid.NewGuid().ToString();
Mock <IHubCallerClients <ISpectatorClient> > mockClients = new Mock <IHubCallerClients <ISpectatorClient> >();
Mock <ISpectatorClient> mockCaller = new Mock <ISpectatorClient>();
mockClients.Setup(clients => clients.Caller).Returns(mockCaller.Object);
Mock <IGroupManager> mockGroups = new Mock <IGroupManager>();
Mock <HubCallerContext> mockContext = new Mock <HubCallerContext>();
mockContext.Setup(context => context.UserIdentifier).Returns(watcher_id);
mockContext.Setup(context => context.ConnectionId).Returns(connectionId);
hub.Context = mockContext.Object;
hub.Clients = mockClients.Object;
hub.Groups = mockGroups.Object;
if (ongoing)
{
await cache.SetStringAsync(SpectatorHub.GetStateId(streamer_id), JsonConvert.SerializeObject(state));
}
await hub.StartWatchingUser(streamer_id);
mockGroups.Verify(groups => groups.AddToGroupAsync(connectionId, SpectatorHub.GetGroupId(streamer_id), default));
mockCaller.Verify(clients => clients.UserBeganPlaying(streamer_id, It.Is <SpectatorState>(m => m.Equals(state))), ongoing ? Times.Once : Times.Never);
}
public async Task GetOrCreateStringAsync_MemoryEmpty_RedisContains_CallTwice()
{
const string generatedKey = "key1";
IMemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
var options = Options.Create(new MemoryDistributedCacheOptions());
var redisCache = new MemoryDistributedCache(options);
await redisCache.SetStringAsync(generatedKey, Test);
var logger = Substitute.For <ILogger <CommonCachingService> >();
var cacheService = new CommonCachingService(memoryCache, redisCache, logger);
var result = await cacheService.GetOrCreateStringAsync(generatedKey, () => Task.FromResult(Test), TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(5));
Assert.AreEqual(Test, result);
result = await cacheService.GetOrCreateStringAsync(generatedKey, () => Task.FromResult(Test), TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(5));
Assert.AreEqual(Test, result);
logger.Received(1).Log(LogLevel.Debug, Arg.Any <EventId>(), Arg.Is <Microsoft.Extensions.Logging.Internal.FormattedLogValues>(flv => flv.ToString() == $"Getting cached value from Distributed cache for key {generatedKey}"), null, Arg.Any <Func <Object, Exception, string> >());
logger.Received(1).Log(LogLevel.Debug, Arg.Any <EventId>(), Arg.Is <Microsoft.Extensions.Logging.Internal.FormattedLogValues>(flv => flv.ToString() == $"Read cached value from Distributed cache for key {generatedKey}"), null, Arg.Any <Func <Object, Exception, string> >());
logger.Received(0).Log(LogLevel.Debug, Arg.Any <EventId>(), Arg.Is <Microsoft.Extensions.Logging.Internal.FormattedLogValues>(flv => flv.ToString() == $"Stored in Distributed cache for key {generatedKey}"), null, Arg.Any <Func <Object, Exception, string> >());
}
public async Task GetOrCreateStringAsync_MemoryEmpty_RedisContains_CallTwice()
{
const string generatedKey = "key1";
IMemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
var options = Options.Create(new MemoryDistributedCacheOptions());
var redisCache = new MemoryDistributedCache(options);
await redisCache.SetStringAsync(generatedKey, Test);
var logger = Substitute.For <LoggerMock <CommonCachingService> >();
var cacheService = new CommonCachingService(memoryCache, redisCache, logger);
var result = await cacheService.GetOrCreateStringAsync(generatedKey, () => Task.FromResult(Test), TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(5));
Assert.AreEqual(Test, result);
result = await cacheService.GetOrCreateStringAsync(generatedKey, () => Task.FromResult(Test), TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(5));
Assert.AreEqual(Test, result);
logger.Received(1).Log(LogLevel.Debug, $"Getting cached value from Distributed cache for key {generatedKey}");
logger.Received(1).Log(LogLevel.Debug, $"Read cached value from Distributed cache for key {generatedKey}");
logger.Received(0).Log(LogLevel.Debug, $"Stored in Distributed cache for key {generatedKey}");
}
public async Task RedisServerTest()
{
//Arrange
var options = Options.Create(new MemoryDistributedCacheOptions());
var cacheRepository = new MemoryDistributedCache(options);
var serverMock = new Mock <IServer>();
serverMock.Setup(x => x.KeysAsync(It.IsAny <int>(),
It.IsAny <RedisValue>(),
It.IsAny <int>(),
It.IsAny <long>(),
It.IsAny <int>(),
It.IsAny <CommandFlags>())).Returns(GetTestValues);
var loggerMock = new Mock <ILogger <RedisServer> >();
var redisServer = new RedisServer(serverMock.Object, cacheRepository, loggerMock.Object);
Expression <Func <Task> > expression = () => _testClassObject.TestMethod("test", 1);
var body = expression.Body as MethodCallExpression;
var argType = body.Arguments[0].GetType();
var parameters = from parameter in body.Arguments
let exp = parameter as MemberExpression
let valueArgument = parameter as ConstantExpression
select new MethodParameter()
{
TypeName = parameter.Type.FullName,
Value = valueArgument.Value.ToString()
};
var cachedObject = new CachedJob()
{
AssemblyName = body.Object.Type.Assembly.GetName().FullName,
ClassName = body.Object.Type.FullName,
MethodName = body.Method.Name,
MethodParameters = parameters.ToArray(),
RunAt = ((DateTimeOffset)DateTime.UtcNow.AddSeconds(2)).UtcDateTime
};
var jsonData = JsonConvert.SerializeObject(cachedObject);
await cacheRepository.SetStringAsync("1", jsonData);
var cancellationToken = new CancellationToken();
var src = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
//Act
await redisServer.StartAsync(cancellationToken);
for (int i = 0; i < 3; i++)
{
await Task.Delay(TimeSpan.FromSeconds(1));
}
src.Cancel();
}
public async Task GetAsyncGeneric_Integration_OK()
{
// arrange
var cache = new MemoryDistributedCache(new OptionsWrapper <MemoryDistributedCacheOptions>(new MemoryDistributedCacheOptions()));
await cache.SetStringAsync("test", "{ \"Id\": 1, \"Name\": \"Test\" }");
var svc = new DistributedCacheService(cache, new NullLogger <DistributedCacheService>());
// act
var result = await svc.GetAsync <MyClass>("test");
// assert
result.ShouldNotBeNull();
result.Id.ShouldBe(1);
result.Name.ShouldBe("Test");
}
public async Task Load_WhenValidToggleAndEtagFilesExist_ReturnsExpectedResult(
[Frozen] MemoryDistributedCache distributedCache,
ToggleCollection toggleCollection,
string etag
)
{
var jsonSerializerSettings = new NewtonsoftJsonSerializerSettings();
var jsonSerializer = new NewtonsoftJsonSerializer(jsonSerializerSettings);
var settings = new DistributedToggleCollectionCacheSettings
{
EtagEntryOptions =
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)
},
ToggleCollectionEntryOptions =
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1)
}
};
using (var ms = new MemoryStream())
{
jsonSerializer.Serialize(ms, toggleCollection);
ms.Seek(0, SeekOrigin.Begin);
await distributedCache.SetAsync(settings.ToggleCollectionKeyName, ms.ToArray(), settings.ToggleCollectionEntryOptions, CancellationToken.None).ConfigureAwait(false);
await distributedCache.SetStringAsync(settings.EtagKeyName, etag, settings.EtagEntryOptions, CancellationToken.None).ConfigureAwait(false);
}
var cache = new DistributedToggleCollectionCache(settings, distributedCache, jsonSerializer);
var result = await cache.Load(CancellationToken.None);
Assert.Equal(etag, result.InitialETag);
AssertionUtils.AssertToggleCollectionsEquivalent(toggleCollection, result.InitialToggleCollection);
}