public async void ClearIfRequired_With_Lower_Version_Should_Not_Invoke_Client() { var service = MoqHelper.CreateWithMocks <RedisGatewayService>(); var versionInRedis = 9; var versionInClient = 10; var ISettingsService = Mock.Get(service.ISettingsService); ISettingsService .Setup(x => x.Get <CacheServiceSettings>()) .Returns(new CacheServiceSettings { Redis = new CacheServiceSettings.RedisSettings { DataVersion = versionInRedis } }); var IRedisClient = new Mock <IRedisClient>(); IRedisClient.Setup(x => x.Get <int>(It.IsAny <string>())).Returns(versionInClient); var IRedisClientFactory = Mock.Get(service.IRedisClientFactory); IRedisClientFactory.Setup(x => x.GetClient()).Returns(IRedisClient.Object); await service.ClearIfRequiredAsync(); IRedisClient.Verify(x => x.FlushDb(), Times.Never); IRedisClient.Verify(x => x.Set(It.IsAny <string>(), versionInRedis), Times.Never); }
public async void GetMany_Should_Invoke_Client() { var service = MoqHelper.CreateWithMocks <RedisGatewayService>(); var dict = new Dictionary <string, string> { { "key1", "value1" }, { "key2", "value2" } }; var IRedisClient = new Mock <IRedisClient>(); IRedisClient .Setup(x => x.GetAll <string>(dict.Keys)) .Returns(dict.ToDictionary(x => x.Key, x => x.Value.ToJsonWithTypeInformation())); var IRedisClientFactory = Mock.Get(service.IRedisClientFactory); IRedisClientFactory.Setup(x => x.GetClient()).Returns(IRedisClient.Object); var result = await service.GetManyAsync <string>(dict.Keys); foreach (var value in result) { Assert.True(dict.Values.ContainsIgnoreCase(value)); } }
public async void GetSet_Should_Invoke_Client() { var service = MoqHelper.CreateWithMocks <RedisGatewayService>(); var values = new HashSet <string> { "v1", "v2" }; var IRedisClient = new Mock <IRedisClient>(); IRedisClient .Setup(x => x.GetAllItemsFromSet("key")) .Returns(values); var IRedisClientFactory = Mock.Get(service.IRedisClientFactory); IRedisClientFactory.Setup(x => x.GetClient()).Returns(IRedisClient.Object); var result = await service.GetSetAsync <string>("key"); foreach (var value in result) { Assert.True(values.ContainsIgnoreCase(value)); } }
private RedisCacheBus CreateService() { var service = MoqHelper.CreateWithMocks <RedisCacheBus>(); var IThreadService = Mock.Get(service.IThreadService); IThreadService .Setup(x => x.QueueUserWorkItem(It.IsAny <WaitCallback>())) .Callback <WaitCallback>(x => x.Invoke(null)); var ISettingsService = Mock.Get(service.ISettingsService); ISettingsService .Setup(x => x.Get <CacheServiceSettings>()) .Returns(new CacheServiceSettings()); var IRedisSubscription = new Mock <IRedisSubscription>(); var IRedisClient = new Mock <IRedisClient>(); IRedisClient .Setup(x => x.CreateSubscription()) .Returns(IRedisSubscription.Object); var IRedisClientFactory = Mock.Get(service.IRedisClientFactory); IRedisClientFactory .Setup(x => x.GetClient()) .Returns(IRedisClient.Object); return(service); }
public async void GetIdByAutoId_Should_AutoId() { var service = MoqHelper.CreateWithMocks <IdTranslationService>(); var ICacheService = Mock.Get(service.ICacheService); var IDatabaseService = Mock.Get(service.IDatabaseService); var store = new List <DummyEntity> { new DummyEntity { Id = "id", AutoId = 123 } }; ICacheService .Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Func <string> >(), It.IsAny <CacheOptions <string> >())) .Returns <string, Func <string>, CacheOptions <string> >((key, factory, options) => Task.FromResult(factory())); IDatabaseService .Setup(x => x.GetQueryable <DummyEntity>()) .Returns(store.AsQueryable()); var verify = await service.GetIdByAutoIdAsync <DummyEntity>(123); Assert.Equal("id", verify); }
private MemoryCacheDelegate CreateService() { var result = MoqHelper.CreateWithMocks <MemoryCacheDelegate>(); result.IMemoryCacheService = new MemoryCacheService(); return(result); }
public async void GetOrCreate_Should_Create_Uncached() { var service = MoqHelper.CreateWithMocks <DynamicCollectionService>(); var store = new List <DummyEntity> { new DummyEntity { } }; var IRepository = new Mock <IRepository <DummyEntity> >(); IRepository.Setup(x => x.GetQueryable()).Returns(store.AsQueryable()); var IContainerService = Mock.Get(service.IContainerService); IContainerService.Setup(x => x.Get <IRepository <DummyEntity> >()).Returns(IRepository.Object); var IDatabaseService = Mock.Get(service.IDatabaseService); IDatabaseService.SetupIgnoreArgs(x => x.QueryAsync <DummyEntity>(null)).Returns(Task.FromResult(store)); var IDynamicCollectionFactory = Mock.Get(service.IDynamicCollectionFactory); IDynamicCollectionFactory .SetupIgnoreArgs(x => x.Create <DummyEntity>(null, null)) .Returns(new DynamicCollection <DummyEntity>(IRepository.Object, new[] { "1" }, null)); var verify = await service.GetOrCreateAsync <DummyEntity>( "key", c => c ); Assert.NotNull(verify); }
public void GetQueryable() { var service = MoqHelper.CreateWithMocks <MemoryDatabaseDelegate>(); var store = new List <DummyEntity> { new DummyEntity { Id = "1", Name = "Foo" }, new DummyEntity { Id = "2", Name = "Bar" } }; var IMemoryCollectionFactory = Mock.Get(service.IMemoryCollectionFactory); IMemoryCollectionFactory.Setup(x => x.GetOrCreateCollection <DummyEntity>()).Returns(store); var query = service.GetQueryable <DummyEntity>(); Assert.Equal(2, query.Count()); }
public async void Remove() { var service = MoqHelper.CreateWithMocks <MemoryDatabaseDelegate>(); var store = new List <DummyEntity> { new DummyEntity { Id = "123", Name = "Foo" } }; var IMemoryCollectionFactory = Mock.Get(service.IMemoryCollectionFactory); IMemoryCollectionFactory.Setup(x => x.GetOrCreateCollection <DummyEntity>()).Returns(store); var entity = new DummyEntity { Id = "123" }; await service.RemoveAsync <DummyEntity>(entity.Id); Assert.DoesNotContain(store, x => x.Id == "123"); }
public async void GetHashCounters_Should_Invoke_Client() { var service = MoqHelper.CreateWithMocks <RedisGatewayService>(); var dict = new Dictionary <string, string> { { "key1", "1" }, { "key2", "2" } }; var IRedisClient = new Mock <IRedisClient>(); IRedisClient.Setup(x => x.GetAllEntriesFromHash("hash")).Returns(dict); var IRedisClientFactory = Mock.Get(service.IRedisClientFactory); IRedisClientFactory.Setup(x => x.GetClient()).Returns(IRedisClient.Object); var result = await service.GetHashCountersAsync("hash"); foreach (var p in result) { Assert.Equal(dict[p.Key], p.Value.ToString()); } IRedisClient.Verify(x => x.GetAllEntriesFromHash("hash"), Times.Once); }
public void GetById_Should_Invoke_Delegate() { var service = MoqHelper.CreateWithMocks <DummyDatabaseServnice>(); var IDatabaseDelegate = Mock.Get(service.IMemoryDatabaseDelegate); service.GetByIdAsync <DummyEntity>("id"); IDatabaseDelegate.Verify(x => x.GetByIdAsync <DummyEntity>(It.IsAny <string>()), Times.Once); }
public void Create_Should_Return_List() { var service = MoqHelper.CreateWithMocks <DynamicCollectionFactory>(); var verify = service.Create <DummyEntity>(new[] { "id" }); Assert.NotNull(verify); }
public void GetQueryable_Should_Invoke_Delegate() { var service = MoqHelper.CreateWithMocks <DummyDatabaseServnice>(); var IDatabaseDelegate = Mock.Get(service.IMemoryDatabaseDelegate); service.GetQueryable <DummyEntity>(); IDatabaseDelegate.Verify(x => x.GetQueryable <DummyEntity>(), Times.Once); }
public async void Command_Without_Start_Should_Throw_Exception() { await Assert.ThrowsAsync <Exception>(async() => { var service = MoqHelper.CreateWithMocks <TestCacheBus>(); await service.RemoveAsync("1"); }); }
public void Save_Should_Invoke_Delegate() { var service = MoqHelper.CreateWithMocks <DummyDatabaseServnice>(); var IDatabaseDelegate = Mock.Get(service.IMemoryDatabaseDelegate); service.SaveAsync(new DummyEntity()); IDatabaseDelegate.Verify(x => x.SaveAsync(It.IsAny <DummyEntity>()), Times.Once); }
public void GetQueryable_Should_Invoke_DatabaseService() { var service = MoqHelper.CreateWithMocks <DummyRepository>(); var IDatabaseService = Mock.Get(service.IDatabaseService); service.GetQueryable(); IDatabaseService.Verify(x => x.GetQueryable <DummyEntity>(), Times.Once); }
public async void GetByName_Should_Invoke_Database() { var service = MoqHelper.CreateWithMocks <DummyRepository>(); var IIdTranslationService = Mock.Get(service.IIdTranslationService); await service.GetByNameAsync("id"); IIdTranslationService.Verify(x => x.GetIdByNameAsync <DummyEntity>(It.IsAny <string>()), Times.Once); }
public async void GetByAutoId_Should_Invoke_IdTranslation() { var service = MoqHelper.CreateWithMocks <DummyRepository>(); var IIdTranslationService = Mock.Get(service.IIdTranslationService); await service.GetByAutoIdAsync(1ul); IIdTranslationService.Verify(x => x.GetIdByAutoIdAsync <DummyEntity>(It.IsAny <ulong>()), Times.Once); }
public async void GetNext_Should_Create_AutoId() { var service = MoqHelper.CreateWithMocks <AutoIdService>(); var IAutoIdRepository = Mock.Get(service.IAutoIdRepository); await service.GetNext <DummyEntity>(); IAutoIdRepository.Verify(x => x.SaveAsync(It.IsAny <AutoId>()), Times.Exactly(2)); }
public async void Register_Should_Add_Key_To_Event() { var service = MoqHelper.CreateWithMocks <CacheEventService>(); var ICacheService = Mock.Get(service.ICacheService); await service.Register("*", "id"); ICacheService.Verify(x => x.AddToSetAsync(It.Is <string>(y => y.Contains("*")), "id"), Times.Once); }
public async void ClearAsyncc_Should_Add_Command() { var service = MoqHelper.CreateWithMocks <TestCacheBus>(); service.Start(); await service.ClearAsync(); Assert.Contains("ClearAsync", service.Commands); }
public async void RemoveFromSetAsyncc_Should_Add_Command() { var service = MoqHelper.CreateWithMocks <TestCacheBus>(); service.Start(); await service.RemoveFromSetAsync("key", "value"); Assert.Contains("RemoveFromSetAsync", service.Commands); }
public async void AddToSetAsyncc_Should_Add_Command() { var service = MoqHelper.CreateWithMocks <TestCacheBus>(); service.Start(); await service.AddToSetAsync("key", new[] { "value " }); Assert.Contains("AddToSetAsync", service.Commands); }
public void Start_Should_Create_Random_Instance_Id() { var service = MoqHelper.CreateWithMocks <TestCacheBus>(); var IRandomService = Mock.Get(service.IRandomService); service.Start(); IRandomService .Verify(x => x.RandomBase24(It.IsAny <int>(), It.IsAny <bool>()), Times.Once); }
public async void PresetName_Should_Invoke_Cache() { var service = MoqHelper.CreateWithMocks <IdTranslationService>(); var ICacheService = Mock.Get(service.ICacheService); await service.PresetNameAsync(new DummyEntity { Id = "id", Name = "Foo" }); ICacheService.VerifyIgnoreArgs(x => x.SetAsync <string>(null, null, null), Times.Once); }
public async void GetById_Should_Invoke_Cache() { var service = MoqHelper.CreateWithMocks <EntityCacheService>(); var ICacheService = Mock.Get(service.ICacheService); await service.GetByIdAsync <DummyEntity>("123"); ICacheService.VerifyIgnoreArgs(x => x.GetAsync <DummyEntity>(null, null, null), Times.Once); }
public async void Insert_Should_Invole_Will_And_Did() { var service = MoqHelper.CreateWithMocks <DummyDatabaseDelegate>(); var dummy = new DummyEntity(); await service.InsertAsync(dummy); Assert.True(service.WillInsertCalled); Assert.True(service.DidInsertCalled); }
public async void Set_Should_Invoke_Cache() { var service = MoqHelper.CreateWithMocks <EntityCacheService>(); var ICacheService = Mock.Get(service.ICacheService); var dummy = new DummyEntity(); await service.SetAsync(dummy); ICacheService.VerifyIgnoreArgs(x => x.SetAsync <DummyEntity>(null, null, null), Times.Once); }
public async void Remove_Should_Invoke_Cache() { var service = MoqHelper.CreateWithMocks <EntityCacheService>(); var ICacheService = Mock.Get(service.ICacheService); var dummy = new DummyEntity(); await service.RemoveAsync <DummyEntity>("123"); ICacheService.Verify(x => x.RemoveAsync(It.IsAny <string>()), Times.Once); }
public async void GetById_None_With_No_Database_Should_Not_Invoke_Cache() { var service = MoqHelper.CreateWithMocks <DummyRepository>(); var IDatabaseService = Mock.Get(service.IDatabaseService); var IEntityCacheService = Mock.Get(service.IEntityCacheService); await service.GetByIdAsync("id"); IEntityCacheService.Verify(x => x.SetAsync(It.IsAny <DummyEntity>()), Times.Never); }