public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken)) { if (DisableSetAsync) { throw new InvalidOperationException(); } return(_cache.SetAsync(key, value, options)); }
public async Task Should_be_valid_when_job_is_requested_to_clear_cache() { await _cache.SetAsync(CacheKeys.Portfolio, Array.Empty <byte>()); _updateCacheJob = new UpdateCacheJob(_cache, _mockPortfolio.Object); await _updateCacheJob.ClearAsync(); _cache.Get(CacheKeys.Portfolio).Should().BeNull(); }
public async Task SetValueToCache() { IDistributedCache cache = new MemoryDistributedCache(); await cache.SetAsync("2", 2, new DistributedCacheEntryOptions()); var value = await cache.GetAsync <int>("2"); value.Should().Be(2); }
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default) { if (DisableSetAsync) { throw new InvalidOperationException(); } if (DelaySetAsync) { token.WaitHandle.WaitOne(TimeSpan.FromSeconds(10)); token.ThrowIfCancellationRequested(); } return(_cache.SetAsync(key, value, options)); }
public async Task SetComplexValueToCache() { IDistributedCache cache = new MemoryDistributedCache(); await cache.SetAsync("foo", new Foo() { Value = 2 }, new DistributedCacheEntryOptions()); var value = await cache.GetAsync <Foo>("foo"); value.Value.Should().Be(2); }
public async Task SetAsyncSerializesObjectAndStoresBytes() { var cache = new MemoryDistributedCache(Options.Create(new MemoryDistributedCacheOptions())); var example = new Example { Name = "The Name" }; await cache.SetAsync("test", example); var bytes = await cache.GetAsync("test"); var json = Encoding.UTF8.GetString(bytes); Assert.Equal(@"{""Name"":""The Name""}", json); }
public async Task SetAsyncUsesExpiryPolicy() { var fixedTime = new DateTimeOffset(2020, 1, 27, 21, 20, 0, TimeSpan.Zero); var mockTime = Substitute.For <ISystemClock>(); mockTime.UtcNow.Returns(fixedTime); var options = new MemoryDistributedCacheOptions { Clock = mockTime }; var cache = new MemoryDistributedCache(Options.Create(options)); var expirationOptions = new DistributedCacheEntryOptions { AbsoluteExpiration = fixedTime.Subtract(TimeSpan.FromSeconds(1)) }; await cache.SetAsync("should_be_gone", new Example { Name = "to expire" }, expirationOptions); var missing = await cache.GetAsync <Example>("should_be_gone"); Assert.Null(missing); }
public async Task Load_WhenTogglesOrEtagFileDoesNotExists_ReturnsEmptyResult( bool toggleCollectionExists, bool etagExists, [Frozen] DistributedToggleCollectionCacheSettings settings, [Frozen] MemoryDistributedCache distributedCache, DistributedToggleCollectionCache cache ) { var jsonSerializerSettings = new NewtonsoftJsonSerializerSettings(); var jsonSerializer = new NewtonsoftJsonSerializer(jsonSerializerSettings); settings.EtagKeyName = "Etag"; settings.ToggleCollectionKeyName = "Toggles"; if (toggleCollectionExists) { var toggleCollection = new ToggleCollection(); 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); } } if (toggleCollectionExists && etagExists) { var etag = Guid.NewGuid().ToString(); distributedCache.SetString(settings.EtagKeyName, etag); } var result = await cache.Load(CancellationToken.None); Assert.Equal(string.Empty, result.InitialETag); Assert.Null(result.InitialToggleCollection); }
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); }
public async Task PostAiMove_PreventRepeatedMoves() { var game = HiveFactory.Create(new[] { "player1", "player2" }); var moves = new Queue <Move>(3); for (var i = 0; i < 3; i++) { var player0Tile = game.Players.First().Tiles.First(t => t.Creature != Creatures.Queen && t.Moves.Any()); game.Move(new Move(player0Tile, player0Tile.Moves.First())); var player1Tile = game.Players.Last().Tiles.First(t => t.Creature != Creatures.Queen && t.Moves.Any()); game.Move(new Move(player1Tile, player1Tile.Moves.First())); } for (var i = 0; i < 2; i++) { var tileToMove = game.Players[i].Tiles.First(t => t.Moves.Any()); game.Move(new Move(tileToMove, tileToMove.Moves.First())); } await _memoryCache.SetAsync( TestHelpers.ExistingGameId, TestHelpers.GetSerializedBytes( new GameState(game.Players, game.Cells, TestHelpers.ExistingGameId, GameStatus.MoveSuccess), TestHelpers.CreateJsonOptions() ) ); await _memoryCache.SetAsync( TestHelpers.ExistingGameId + "-moves-1", TestHelpers.GetSerializedBytes(moves, TestHelpers.CreateJsonOptions()) ); var actionResult = await _controller.AiMove(TestHelpers.ExistingGameId, 1); actionResult.Should().BeOfType <AcceptedResult>(); }
public MessageProcessorTests() { delivererMock = new Mock <IMailDeliverer>(); delivererMock .Setup(d => d.DeliverAsync(It.Is <EmailMessage>(m => m.Subject == DELIVER_FAILURE))) .ThrowsAsync(new Exception()); storageMock = new Mock <IMailStorage>(); storageMock .Setup(s => s.SetProcessedAsync(It.Is <EmailMessage>(m => m.Subject == SET_PROCESSED_FAILURE))) .ThrowsAsync(new Exception()); storageMock .Setup(s => s.SetErrorAsync(It.Is <EmailMessage>(m => m.Subject == SET_ERROR_FAILURE), It.IsAny <string>())) .ThrowsAsync(new Exception()); storageMock .Setup(s => s.SetSentAsync(It.Is <EmailMessage>(m => m.Subject == SET_SENT_FAILURE))) .ThrowsAsync(new Exception()); cacheMock = new Mock <IDistributedCache>(); var internalCache = new MemoryDistributedCache(Options.Create <MemoryDistributedCacheOptions>(new MemoryDistributedCacheOptions())); cacheMock .Setup(c => c.GetAsync(It.Is <string>(m => m == CACHE_GET_EXCEPTION.ToString()), It.IsAny <CancellationToken>())) .ThrowsAsync(new Exception()); cacheMock .Setup(c => c.GetAsync(It.Is <string>(m => m != CACHE_GET_EXCEPTION.ToString()), It.IsAny <CancellationToken>())) .Returns(async(string key, CancellationToken c) => await internalCache.GetAsync(key, c)); cacheMock .Setup(c => c.SetAsync(It.Is <string>(m => m == CACHE_SET_EXCEPTION.ToString()), It.IsAny <byte[]>(), It.IsAny <DistributedCacheEntryOptions>(), It.IsAny <CancellationToken>())) .ThrowsAsync(new Exception()); cacheMock .Setup(c => c.SetAsync(It.Is <string>(m => m != CACHE_SET_EXCEPTION.ToString()), It.IsAny <byte[]>(), It.IsAny <DistributedCacheEntryOptions>(), It.IsAny <CancellationToken>())) .Returns(async(string key, byte[] value, DistributedCacheEntryOptions o, CancellationToken c) => await internalCache.SetAsync(key, value, o, c)); var logger = new NullLogger <MessageProcessor>(); messageProcessor = new MessageProcessor(delivererMock.Object, storageMock.Object, cacheMock.Object, logger); }