public void TestInitializer() { // initialize fake context _fakeContext = InitializeFakeContext<FacilitiesController>(); // explicitly create fake dependencies that need to be intercepted // (all other fake dependencies will be implicitly created by _fakeContext.Resolve<>) _fakeBusinessFacade = A.Fake<IBusinessFacade>(); _fakeLoadedSubscriber = A.Fake<ILoadedSubscriber>(); _fakeCurrentLocation = A.Fake<ILoadedLocation>(); _fakeCurrentUser = A.Fake<ILoggedInUser>(); _fakePermissions = A.Fake<IPermissions>(); // provide fake dependencies to context _fakeContext.Provide(_fakeBusinessFacade); _fakeContext.Provide(_fakeLoadedSubscriber); _fakeContext.Provide(_fakeCurrentLocation); _fakeContext.Provide(_fakeCurrentUser); _fakeContext.Provide(_fakePermissions); // create system-under-test instance _facilitiesControllerForTest = _fakeContext.Resolve<FacilitiesController>(); // create fake data _usiForTest = TestDataRepository.GetUsiForTest(); _locationIdForTest = TestDataRepository.GetLocationIdForTest(); _serviceAddressControlNumberForTests = TestDataRepository.GetServiceAddressControlNumberForTest(); _dpiRegionForTests = TestDataRepository.GetDpiRegionForTest(); }
public void CallInfo40000TimesOnMultipleThreads() { using (var fake = new AutoFake(callsDoNothing: true)) { //set up connection configuration that holds a connection pool //with '_uris' (see the constructor) fake.Provide<IConnectionConfigurationValues>(_config); //we want to use our special concurrencytestconnection //this randonly throws on any node but 9200 and sniffing will represent a different //view of the cluster each time but always holding node 9200 fake.Provide<IConnection>(new ConcurrencyTestConnection(this._config)); //prove a real Transport with its unspecified dependencies //as fakes FakeCalls.ProvideDefaultTransport(fake); //create a real ElasticsearchClient with it unspecified dependencies as fakes var client = fake.Resolve<ElasticsearchClient>(); int seen = 0; //We'll call Info() 10.000 times on 4 threads //This should not throw any exceptions even if connections sometime fail at a node level //because node 9200 is always up and running Assert.DoesNotThrow(()=> { Action a = () => { for(var i=0;i<10000;i++) { client.Info<VoidResponse>(); Interlocked.Increment(ref seen); } }; var thread1 = new Thread(()=>a()); var thread2 = new Thread(()=>a()); var thread3 = new Thread(()=>a()); var thread4 = new Thread(()=>a()); thread1.Start(); thread2.Start(); thread3.Start(); thread4.Start(); thread1.Join(); thread2.Join(); thread3.Join(); thread4.Join(); }); //we should have seen 40.000 increments //Sadly we can't use FakeItEasy's to ensure get is called 40.000 times //because it internally uses fixed arrays that will overflow :) seen.Should().Be(40000); } }
public void ServerExceptionIsCaught_KeepResponse(int status, string exceptionType, string exceptionMessage) { var response = CreateServerExceptionResponse(status, exceptionType, exceptionMessage); using (var fake = new AutoFake(callsDoNothing: true)) { var connectionConfiguration = new ConnectionConfiguration() .ExposeRawResponse(true); fake.Provide<IConnectionConfigurationValues>(connectionConfiguration); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Bad(connectionConfiguration, response: response)); var client = fake.Resolve<ElasticsearchClient>(); var result = client.Info(); result.Success.Should().BeFalse(); AssertServerErrorsOnResponse(result, status, exceptionType, exceptionMessage); result.ResponseRaw.Should().NotBeNull(); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
private ITransport ProvideTransport(AutoFake fake) { var dateTimeParam = new TypedParameter(typeof(IDateTimeProvider), null); var memoryStreamParam = new TypedParameter(typeof(IMemoryStreamProvider), null); var serializerParam = new TypedParameter(typeof(IElasticsearchSerializer), null); return fake.Provide<ITransport, Transport>(dateTimeParam, serializerParam, memoryStreamParam); }
public void IfResponseIsKnowError_DoNotRetry_ThrowServerException_Async(int status, string exceptionType, string exceptionMessage) { var response = CreateServerExceptionResponse(status, exceptionType, exceptionMessage); using (var fake = new AutoFake(callsDoNothing: true)) { var connectionPool = new StaticConnectionPool(new[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9201"), }); var connectionConfiguration = new ConnectionConfiguration(connectionPool) .ThrowOnElasticsearchServerExceptions() .ExposeRawResponse(false); fake.Provide<IConnectionConfigurationValues>(connectionConfiguration); FakeCalls.ProvideDefaultTransport(fake); var pingCall = FakeCalls.PingAtConnectionLevelAsync(fake); pingCall.Returns(FakeResponse.OkAsync(connectionConfiguration)); var getCall = FakeCalls.GetCall(fake); getCall.Returns(FakeResponse.AnyAsync(connectionConfiguration, status, response: response)); var client = fake.Resolve<ElasticsearchClient>(); var e = Assert.Throws<ElasticsearchServerException>(async ()=>await client.InfoAsync()); AssertServerErrorsOnResponse(e, status, exceptionType, exceptionMessage); //make sure a know ElasticsearchServerException does not cause a retry //In this case we want to fail early getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public async void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); this.ProvideTransport(fake); var getCall = A.CallTo(() => fake.Resolve<IConnection>().Get(A<Uri>._)); Func<ElasticsearchResponse> badTask = () => { throw new Exception(); }; var t = new Task<ElasticsearchResponse>(badTask); t.Start(); getCall.Returns(t); var client = fake.Resolve<ElasticsearchClient>(); client.Settings.MaxRetries.Should().Be(_retries); try { var result = await client.InfoAsync(); } catch (Exception e) { Assert.AreEqual(e.GetType(), typeof(OutOfNodesException)); } getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1)); } }
public async void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); //return a started task that throws Func<ElasticsearchResponse<Dictionary<string, object>>> badTask = () => { throw new Exception(); }; var t = new Task<ElasticsearchResponse<Dictionary<string, object>>>(badTask); t.Start(); getCall.Returns(t); var client = fake.Resolve<ElasticsearchClient>(); client.Settings.MaxRetries.Should().Be(_retries); try { var result = await client.InfoAsync(); } catch (AggregateException ae) { Assert.AreEqual(typeof(MaxRetryException), ae.InnerException.GetType()); } catch (Exception e) { Assert.AreEqual(typeof(MaxRetryException), e.GetType()); } getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1)); } }
public void CallInfo40000TimesOnMultipleThreads() { using (var fake = new AutoFake(callsDoNothing: true)) { //set up connection configuration that holds a connection pool //with '_uris' (see the constructor) fake.Provide<IConnectionConfigurationValues>(_config); //prove a real HttpTransport with its unspecified dependencies //as fakes var connection = fake.Provide<IConnection>(new ConcurrencyTestConnection(this._config)); this.ProvideTransport(fake); //create a real ElasticsearchClient with it unspecified dependencies as fakes var client = fake.Resolve<ElasticsearchClient>(); int seen = 0; Assert.DoesNotThrow(()=> { Action a = () => { for(var i=0;i<10000;i++) { client.Info(); Interlocked.Increment(ref seen); } }; var thread1 = new Thread(()=>a()); var thread2 = new Thread(()=>a()); var thread3 = new Thread(()=>a()); var thread4 = new Thread(()=>a()); thread1.Start(); thread2.Start(); thread3.Start(); thread4.Start(); thread1.Join(); thread2.Join(); thread3.Join(); thread4.Join(); }); seen.Should().Be(40000); } }
public void SniffCalledOnceAndEachEnpointPingedOnce() { using (var fake = new AutoFake(callsDoNothing: true)) { //It's recommended to only have on instance of your connection pool //Be sure to register it as Singleton in your IOC var uris = new[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9201") }; var connectionPool = new SniffingConnectionPool(uris); var config = new ConnectionConfiguration(connectionPool) .SniffOnStartup(); fake.Provide<IConnectionConfigurationValues>(config); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(FakeResponse.Ok(config)); var sniffCall = FakeCalls.Sniff(fake, config, uris); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Ok(config)); var transport1 = FakeCalls.ProvideRealTranportInstance(fake); var transport2 = FakeCalls.ProvideRealTranportInstance(fake); var transport3 = FakeCalls.ProvideRealTranportInstance(fake); var transport4 = FakeCalls.ProvideRealTranportInstance(fake); transport1.Should().NotBe(transport2); var client1 = new ElasticsearchClient(config, transport: transport1); client1.Info(); client1.Info(); client1.Info(); client1.Info(); var client2 = new ElasticsearchClient(config, transport: transport2); client2.Info(); client2.Info(); client2.Info(); client2.Info(); var client3 = new ElasticsearchClient(config, transport: transport3); client3.Info(); client3.Info(); client3.Info(); client3.Info(); var client4 = new ElasticsearchClient(config, transport: transport4); client4.Info(); client4.Info(); client4.Info(); client4.Info(); sniffCall.MustHaveHappened(Repeated.Exactly.Once); //sniff validates first node, one new node should be pinged before usage. pingCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void ShouldNotRetryOn500() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Any(_connectionConfig, 500)); var client = fake.Resolve<ElasticsearchClient>(); Assert.DoesNotThrow(() => client.Info()); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void ThrowsException() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetSyncCall(fake); getCall.Throws<Exception>(); var client = fake.Resolve<ElasticsearchClient>(); Assert.Throws<Exception>(() => client.Info()); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public async void ShouldNotRetryOn400_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); var task = Task.FromResult(FakeResponse.Any(_connectionConfig, 400)); getCall.Returns(task); var client = fake.Resolve<ElasticsearchClient>(); var result = await client.InfoAsync(); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
private void Call(int status, string exceptionType, string exceptionMessage, AutoFake fake, MemoryStream response, bool exposeRawResponse = false) { var connectionConfiguration = new ConnectionConfiguration() .ThrowOnElasticsearchServerExceptions() .ExposeRawResponse(exposeRawResponse); fake.Provide<IConnectionConfigurationValues>(connectionConfiguration); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Bad(connectionConfiguration, response: response)); var client = fake.Resolve<ElasticsearchClient>(); var e = Assert.Throws<ElasticsearchServerException>(()=>client.Info()); AssertServerErrorsException(e, status, exceptionType, exceptionMessage); getCall.MustHaveHappened(Repeated.Exactly.Once); }
public void ShouldNotRetryWhenMaxRetriesIs0_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { var connectionConfiguration = new ConnectionConfiguration().MaximumRetries(0); fake.Provide<IConnectionConfigurationValues>(connectionConfiguration); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); getCall.Returns(FakeResponse.Bad(connectionConfiguration)); var client = fake.Resolve<ElasticsearchClient>(); Assert.DoesNotThrow(async () => await client.InfoAsync()); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); this.ProvideTransport(fake); var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._)); getCall.Throws<Exception>(); var client = fake.Resolve<ElasticsearchClient>(); client.Settings.MaxRetries.Should().Be(_retries); Assert.Throws<OutOfNodesException>(()=> client.Info()); getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1)); } }
public void ThrowsMaxRetryException_AndRetriesTheSpecifiedTimes_HardIConnectionException_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); //return a started task that throws getCall.Throws<Exception>(); var client = fake.Resolve<ElasticsearchClient>(); client.Settings.MaxRetries.Should().Be(_retries); Assert.Throws<MaxRetryException>(async () => await client.InfoAsync()); getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1)); } }
public void OnConnectionException_WithoutPooling_Retires() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetSyncCall(fake); getCall.Throws((o)=> new Exception("inner")); var client = fake.Resolve<ElasticsearchClient>(); client.Settings.MaxRetries.Should().NotHaveValue(); var e = Assert.Throws<Exception>(() => client.Info()); e.Message.Should().Be("inner"); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
private ElasticsearchResponse<DynamicDictionary> Call(int status, string exceptionType, string exceptionMessage, AutoFake fake, MemoryStream response, bool exposeRawResponse = false) { var connectionConfiguration = new ConnectionConfiguration() .ExposeRawResponse(exposeRawResponse); fake.Provide<IConnectionConfigurationValues>(connectionConfiguration); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Bad(connectionConfiguration, response: response)); var client = fake.Resolve<ElasticsearchClient>(); var result = client.Info(); result.Success.Should().BeFalse(); AssertServerErrorsOnResponse(result, status, exceptionType, exceptionMessage); getCall.MustHaveHappened(Repeated.Exactly.Once); return result; }
public void SniffIsCalledAfterItHasGoneOutOfDate() { using (var fake = new AutoFake()) { var dateTimeProvider = fake.Resolve<IDateTimeProvider>(); var nowCall = A.CallTo(()=>dateTimeProvider.Now()); nowCall.ReturnsNextFromSequence( DateTime.UtcNow, //initial sniff time (set even if not sniff_on_startup DateTime.UtcNow, //info call 1 DateTime.UtcNow, //info call 2 DateTime.UtcNow.AddMinutes(10), //info call 3 DateTime.UtcNow.AddMinutes(10), //set now after sniff 3 DateTime.UtcNow.AddMinutes(20), //info call 4 DateTime.UtcNow.AddMinutes(20), //set now after sniff 4 DateTime.UtcNow.AddMinutes(22) //info call 5 ); var uris = new[] { new Uri("http://localhost:9200") }; var connectionPool = new SniffingConnectionPool(uris); var config = new ConnectionConfiguration(connectionPool) .SniffLifeSpan(TimeSpan.FromMinutes(4)); fake.Provide<IConnectionConfigurationValues>(config); var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider); var connection = fake.Resolve<IConnection>(); var sniffCall = FakeCalls.Sniff(fake, config, uris); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(FakeResponse.Ok(config)); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Ok(config)); var client1 = fake.Resolve<ElasticsearchClient>(); var result = client1.Info(); //info call 1 result = client1.Info(); //info call 2 result = client1.Info(); //info call 3 result = client1.Info(); //info call 4 result = client1.Info(); //info call 5 sniffCall.MustHaveHappened(Repeated.Exactly.Twice); nowCall.MustHaveHappened(Repeated.Exactly.Times(8)); } }
public void Hard_IConnectionException_AsyncCall_WithoutPooling_DoesNot_Retry_AndRethrows() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); //return a started task that throws getCall.Throws((o)=> new Exception("inner")); var client = fake.Resolve<ElasticsearchClient>(); client.Settings.MaxRetries.Should().Be(_retries); var e = Assert.Throws<Exception>(async () => await client.InfoAsync()); e.Message.Should().Be("inner"); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void ThrowsException_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); //return a started task that throws Func<ElasticsearchResponse<Stream>> badTask = () => { throw new Exception(); }; var t = new Task<ElasticsearchResponse<Stream>>(badTask); t.Start(); getCall.Returns(t); var client = fake.Resolve<ElasticsearchClient>(); Assert.Throws<Exception>(async () => await client.InfoAsync()); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void StopsForHelp(string command) { AutoFake.Provide <IAssemblyProvider>(new TestAssemblyProvider()); var builder = AutoFake.Resolve <CommandLineBuilder>(); builder .AddCommand <Cmd>("cmd1"); builder .AddCommand <Cmd>("cmd2"); builder .AddCommand <Cmd>("cmd3"); builder .AddCommand <Cmd>("cmd4"); builder .AddCommand <Cmd>("cmd5"); var response = builder .Build(typeof(CommandLineBuilderTests).GetTypeInfo().Assembly); var result = response.Execute(AutoFake.Resolve <IServiceProvider>(), command.Split(' ')); result.Should().BeGreaterOrEqualTo(0); }
public void SniffOnStartupCallsSniffOnlyOnce() { using (var fake = new AutoFake(callsDoNothing: true)) { //It's recommended to only have on instance of your connection pool //Be sure to register it as Singleton in your IOC var uris = new[] { new Uri("http://localhost:9200") }; var connectionPool = new SniffingConnectionPool(uris); var config = new ConnectionConfiguration(connectionPool) .DisablePing() .SniffOnStartup(); fake.Provide <IConnectionConfigurationValues>(config); var sniffCall = FakeCalls.Sniff(fake, config, uris); var transport = FakeCalls.ProvideDefaultTransport(fake); var client1 = new ElasticsearchClient(config, transport: transport); var client2 = new ElasticsearchClient(config, transport: transport); var client3 = new ElasticsearchClient(config, transport: transport); var client4 = new ElasticsearchClient(config, transport: transport); sniffCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void SniffIsCalledAfterItHasGoneOutOfDate() { using (var fake = new AutoFake()) { var dateTimeProvider = fake.Resolve <IDateTimeProvider>(); var nowCall = A.CallTo(() => dateTimeProvider.Now()); nowCall.ReturnsNextFromSequence( DateTime.UtcNow, //initial sniff time (set even if not sniff_on_startup DateTime.UtcNow, //info call 1 DateTime.UtcNow, //info call 2 DateTime.UtcNow.AddMinutes(10), //info call 3 DateTime.UtcNow.AddMinutes(10), //set now after sniff 3 DateTime.UtcNow.AddMinutes(20), //info call 4 DateTime.UtcNow.AddMinutes(20), //set now after sniff 4 DateTime.UtcNow.AddMinutes(22) //info call 5 ); var uris = new[] { new Uri("http://localhost:9200") }; var connectionPool = new SniffingConnectionPool(uris); var config = new ConnectionConfiguration(connectionPool) .SniffLifeSpan(TimeSpan.FromMinutes(4)); fake.Provide <IConnectionConfigurationValues>(config); var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider); var connection = fake.Resolve <IConnection>(); var sniffCall = FakeCalls.Sniff(fake, config, uris); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Ok(config)); var client1 = fake.Resolve <ElasticsearchClient>(); client1.Info(); //info call 1 client1.Info(); //info call 2 client1.Info(); //info call 3 client1.Info(); //info call 4 client1.Info(); //info call 5 sniffCall.MustHaveHappened(Repeated.Exactly.Twice); nowCall.MustHaveHappened(Repeated.Exactly.Times(8)); } }
public void ThrowsMaxRetryException_AndRetriesTheSpecifiedTimes_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide <IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); //return a started task that throws Func <ElasticsearchResponse <Stream> > badTask = () => { throw new Exception(); }; var t = new Task <ElasticsearchResponse <Stream> >(badTask); t.Start(); getCall.Returns(t); var client = fake.Resolve <ElasticsearchClient>(); client.Settings.MaxRetries.Should().Be(_retries); Assert.Throws <MaxRetryException>(async() => await client.InfoAsync()); getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1)); } }
public void SniffOnStartupCallsSniffOnlyOnce() { using (var fake = new AutoFake(callsDoNothing: true)) { //It's recommended to only have on instance of your connection pool //Be sure to register it as Singleton in your IOC var uris = new[] { new Uri("http://localhost:9200") }; var connectionPool = new SniffingConnectionPool(uris); var config = new ConnectionConfiguration(connectionPool) .DisablePing() .SniffOnStartup(); fake.Provide<IConnectionConfigurationValues>(config); var sniffCall = FakeCalls.Sniff(fake, config, uris); var transport = FakeCalls.ProvideDefaultTransport(fake); var client1 = new ElasticsearchClient(config, transport: transport); var client2 = new ElasticsearchClient(config, transport: transport); var client3 = new ElasticsearchClient(config, transport: transport); var client4 = new ElasticsearchClient(config, transport: transport); sniffCall.MustHaveHappened(Repeated.Exactly.Once); } }
public async void ShouldRetryOn503_Async() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide <IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); getCall.Returns(Task.FromResult(FakeResponse.Bad(_connectionConfig))); var client = fake.Resolve <ElasticsearchClient>(); try { var result = await client.InfoAsync(); } catch (MaxRetryException e) { Assert.AreEqual(e.GetType(), typeof(MaxRetryException)); } getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1)); } }
public void MustRegisterListeners_Explicitly() { var configurationDelegate = A.Fake <MartenConfigurationDelegate>(); var componentConfigurationDelegate = A.Fake <MartenComponentConfigurationDelegate>(); AutoFake.Provide <IServiceCollection>(new ServiceCollection()); var servicesBuilder = AutoFake.Resolve <ServicesBuilder>(); servicesBuilder.Services.AddTransient <MartenRegistry, MyMartenRegistry>(); servicesBuilder.Services.AddSingleton <ILoggerFactory>(LoggerFactory); servicesBuilder.Services.AddSingleton <IClock>( new FakeClock(Instant.FromDateTimeOffset(DateTimeOffset.Now), Duration.FromSeconds(1)) ); var martenBuilder = servicesBuilder .WithMarten() .AddStartupFilter() .Configure(configurationDelegate) .Configure(componentConfigurationDelegate); servicesBuilder.Services.AddScoped <IMartenContext>(_ => new MartenContext() { User = new MartenUser <string>(() => "abc123") }); martenBuilder.UseDirtyTrackedSession(); var serviceProvider = servicesBuilder.Build(); var options = serviceProvider.GetRequiredService <IOptions <StoreOptions> >().Value; options.Connection(() => new NpgsqlConnection()); using (var scope = serviceProvider.GetService <IServiceScopeFactory>().CreateScope()) { var session = scope.ServiceProvider.GetService <IDocumentStore>().LightweightSession(); session.Listeners.Count.Should().Be(1); } }
public void ShouldNotThrowAndNotRetrySniffOnConnectionFault403() { using (var fake = new AutoFake(callsDoNothing: true)) { var uris = new[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9201"), new Uri("http://localhost:9202") }; var connectionPool = new SniffingConnectionPool(uris, randomizeOnStartup: false); var config = new ConnectionConfiguration(connectionPool) .SniffOnConnectionFault(); fake.Provide<IConnectionConfigurationValues>(config); FakeCalls.ProvideDefaultTransport(fake); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(FakeResponse.Ok(config)); var sniffCall = FakeCalls.Sniff(fake); var seenPorts = new List<int>(); sniffCall.ReturnsLazily((Uri u, IRequestConfiguration c) => { seenPorts.Add(u.Port); return FakeResponse.Any(config, 403); }); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Bad(config)); var client = fake.Resolve<ElasticsearchClient>(); Assert.DoesNotThrow(() => client.Info()); sniffCall.MustHaveHappened(Repeated.Exactly.Once); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void ShouldNotThrowAndNotRetrySniffOnConnectionFault401() { using (var fake = new AutoFake(callsDoNothing: true)) { var uris = new[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9201"), new Uri("http://localhost:9202") }; var connectionPool = new SniffingConnectionPool(uris, randomizeOnStartup: false); var config = new ConnectionConfiguration(connectionPool) .SniffOnConnectionFault(); fake.Provide <IConnectionConfigurationValues>(config); FakeCalls.ProvideDefaultTransport(fake); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(FakeResponse.Ok(config)); var sniffCall = FakeCalls.Sniff(fake); var seenPorts = new List <int>(); sniffCall.ReturnsLazily((Uri u, IRequestConfiguration c) => { seenPorts.Add(u.Port); return(FakeResponse.Any(config, 401)); }); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Bad(config)); var client = fake.Resolve <ElasticsearchClient>(); Assert.DoesNotThrow(() => client.Info()); sniffCall.MustHaveHappened(Repeated.Exactly.Once); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void Soft_IConnectionException_AsyncCall_WithoutPooling_DoesNot_Retry_AndRethrows() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide <IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); //return a started task that throws Func <ElasticsearchResponse <Stream> > badTask = () => { throw new Exception("inner"); }; var t = new Task <ElasticsearchResponse <Stream> >(badTask); t.Start(); getCall.Returns(t); var client = fake.Resolve <ElasticsearchClient>(); client.Settings.MaxRetries.Should().Be(_retries); var e = Assert.Throws <Exception>(async() => await client.InfoAsync()); e.Message.Should().Be("inner"); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void ShouldResolveConventionsUsingTheServiceProvider() { var properties = new ServiceProviderDictionary(); AutoFake.Provide <IServiceProvider>(properties); var scanner = AutoFake.Resolve <Scanner>(); properties.Add(typeof(IConventionScanner), scanner); var fakeService = A.Fake <IService>(); properties.Add(typeof(IService), fakeService); scanner.AppendConvention <F>(); var result = scanner.BuildProvider().Get <IServiceConvention, ServiceConventionDelegate>(); var item = result.First().Convention; item.Should().BeOfType <F>(); ((F)item !).Scanner.Should().NotBeNull(); ((F)item !).Scanner.Should().BeSameAs(scanner); ((F)item !).Service.Should().BeSameAs(fakeService); }
public void AddsLogging() { var properties = new ServiceProviderDictionary(); AutoFake.Provide <IServiceProviderDictionary>(properties); AutoFake.Provide <IDictionary <object, object?> >(properties); AutoFake.Provide <IServiceProvider>(properties); var configuration = new ConfigurationBuilder().Build(); AutoFake.Provide <IConfiguration>(configuration); properties[typeof(ILogger)] = Logger; var scanner = AutoFake.Resolve <SimpleConventionScanner>(); AutoFake.Provide <IConventionScanner>(scanner); var services = new ServiceCollection(); AutoFake.Provide <IServiceCollection>(services); var builder = AutoFake.Resolve <HostBuilder>(); var sb = AutoFake.Resolve <ServicesBuilder>(); sb.Services.AddLogging(x => x.AddConsole().AddDebug());
public void SupportsInjection_Creating_On_Construction() { AutoFake.Provide <IAssemblyProvider>(new TestAssemblyProvider()); var builder = AutoFake.Resolve <CommandLineBuilder>(); builder .AddCommand <InjectionConstructor>("constructor"); builder .AddCommand <InjectionExecute>("execute"); builder.OnParse(state => { state.IsDefaultCommand.Should().BeFalse(); }); var service = AutoFake.Resolve <IService>(); A.CallTo(() => service.ReturnCode).Returns(1000); var response = builder.Build(typeof(CommandLineBuilderTests).GetTypeInfo().Assembly); var result = response.Execute(ServiceProvider, "constructor"); result.Should().Be(1000); A.CallTo(() => service.ReturnCode).MustHaveHappened(1, Times.Exactly); }
public void ConstructTheContainerAndRegisterWithApplication() { AutoFake.Provide <IServiceCollection>(new ServiceCollection()); AutoFake.Provide <IContainer>(new Container()); AutoFake.Provide <IAssemblyProvider>(new TestAssemblyProvider()); AutoFake.Provide <IConventionScanner, BasicConventionScanner>(); var servicesBuilder = AutoFake.Resolve <DryIocBuilder>(); servicesBuilder.ConfigureContainer( c => c.RegisterInstance(A.Fake <IAbc>()) ); servicesBuilder.Services.AddSingleton(A.Fake <IAbc2>()); servicesBuilder.ConfigureContainer( c => c.RegisterInstance(A.Fake <IAbc4>()) ); var items = servicesBuilder.Build(); items.Resolve <IAbc>(IfUnresolved.ReturnDefault).Should().NotBeNull(); items.Resolve <IAbc2>(IfUnresolved.ReturnDefault).Should().NotBeNull(); items.Resolve <IAbc3>(IfUnresolved.ReturnDefault).Should().BeNull(); items.Resolve <IAbc4>(IfUnresolved.ReturnDefault).Should().NotBeNull(); }
public void Soft_IConnectionException_AsyncCall_WithoutPooling_Retries_AndThrows() { using (var fake = new AutoFake(callsDoNothing: true)) { fake.Provide<IConnectionConfigurationValues>(_connectionConfig); FakeCalls.ProvideDefaultTransport(fake); var getCall = FakeCalls.GetCall(fake); //return a started task that throws Func<ElasticsearchResponse<Stream>> badTask = () => { throw new Exception("inner"); }; var t = new Task<ElasticsearchResponse<Stream>>(badTask); t.Start(); getCall.Returns(t); var client = fake.Resolve<ElasticsearchClient>(); client.Settings.MaxRetries.Should().NotHaveValue(); var e = Assert.Throws<Exception>(async () => await client.InfoAsync()); e.Message.Should().Be("inner"); getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void SendsNotificationThrough_OnBuild_Observable_ForMicrosoftExtensions() { var assemblyProvider = AutoFake.Provide <IAssemblyProvider>(new TestAssemblyProvider()); AutoFake.Provide <IServiceCollection>(new ServiceCollection()); AutoFake.Provide(new ContainerBuilder()); var servicesBuilder = AutoFake.Resolve <AutofacBuilder>(); A.CallTo( () => AutoFake.Resolve <IAssemblyCandidateFinder>().GetCandidateAssemblies(A <IEnumerable <string> > ._) ) .Returns(assemblyProvider.GetAssemblies()); var observer = A.Fake <IObserver <IServiceProvider> >(); var observerApplication = A.Fake <IObserver <IServiceProvider> >(); var observerSystem = A.Fake <IObserver <IServiceProvider> >(); ((IServiceConventionContext)servicesBuilder).OnBuild.Subscribe(observer); var items = servicesBuilder.Build(); A.CallTo(() => observer.OnNext(A <IServiceProvider> .Ignored)).MustHaveHappenedOnceExactly(); }
public void AConnectionMustBeMadeEvenIfAllNodesAreDead() { using (var fake = new AutoFake(callsDoNothing: true)) { //make sure we retry one more time then we have nodes //original call + 4 retries == 5 fake.Provide<IConnectionConfigurationValues>( new ConnectionConfiguration(_connectionPool) .MaximumRetries(4) ); //set up our GET to / to return 4 503's followed by a 200 var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync<Dictionary<string, object>>(A<Uri>._, A<object>._)); getCall.ReturnsNextFromSequence( ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null), ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null), ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null), ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null), ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 200, "GET", "/", null) ); var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._)); pingCall.Returns(true); //setup client this.ProvideTransport(fake); var client = fake.Resolve<ElasticsearchClient>(); //Do not throw because by miracle the 4th retry manages to give back a 200 //even if all nodes have been marked dead. Assert.DoesNotThrow(()=> client.Info()); //original call + 4 retries == 5 getCall.MustHaveHappened(Repeated.Exactly.Times(5)); //ping must have been send out 4 times to the 4 nodes being used for the first time pingCall.MustHaveHappened(Repeated.Exactly.Times(4)); } }
public void Should_Work_With_CanBeAssigned_Document() { AutoFake.Provide <IServiceCollection>(new ServiceCollection()); var servicesBuilder = AutoFake.Resolve <ServicesBuilder>(); servicesBuilder.Services.AddTransient <MartenRegistry, MyMartenRegistry>(); servicesBuilder.Services.AddSingleton <ILoggerFactory>(LoggerFactory); servicesBuilder.Services.AddSingleton <IClock>( new FakeClock(Instant.FromDateTimeOffset(DateTimeOffset.Now), Duration.FromSeconds(1)) ); var martenBuilder = servicesBuilder.WithMarten(); servicesBuilder.Services.AddScoped <IMartenContext>(_ => new MartenContext() { User = new MartenUser <long>(() => 123456) }); martenBuilder.UseDirtyTrackedSession(); var serviceProvider = servicesBuilder.Build(); var options = serviceProvider.GetRequiredService <IOptions <StoreOptions> >().Value; options.Connection(() => new NpgsqlConnection(_fixture.ConnectionString.ToString())); using (var scope = serviceProvider.CreateScope()) { using (var session = scope.ServiceProvider.GetService <ISecureQuerySession>()) { var c = session.Query <CanBeAssigned>() .ToCommand(); c.CommandText.Should().Be("select d.data, d.id, d.mt_version from public.mt_doc_securityqueryprovidertests_canbeassigned as d where d.data @> :arg0"); } } }
public void Should_Not_Retry_On_IConnection_Exception() { using (var fake = new AutoFake(callsDoNothing: true)) { //set up connection configuration that holds a connection pool //with '_uris' (see the constructor) fake.Provide<IConnectionConfigurationValues>(_config); //prove a real HttpTransport with its unspecified dependencies //as fakes this.ProvideTransport(fake); //set up fake for a call on IConnection.GetSync so that it always throws //an exception var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.AnyWithException(_config, -1, innerException: new Exception("inner"))); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(_ok); //create a real ElasticsearchClient with it unspecified dependencies //as fakes var client = fake.Resolve<ElasticsearchClient>(); //our settings dictate retrying 2 times client.Settings.MaxRetries.Should().Be(2); //the single node connection pool always reports 0 for maxretries client.Settings.ConnectionPool.MaxRetries.Should().Be(0); // var exception = Assert.Throws<Exception>(()=> client.Info()); exception.Message.Should().Be("inner"); //the GetSync method must in total have been called the number of nodes times. getCall.MustHaveHappened(Repeated.Exactly.Once); } }
public void ShouldThrowAndNotRetrySniffOnStartup403() { using (var fake = new AutoFake(callsDoNothing: true)) { var uris = new[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9201"), new Uri("http://localhost:9202") }; var connectionPool = new SniffingConnectionPool(uris, randomizeOnStartup: false); var config = new ConnectionConfiguration(connectionPool) .SniffOnStartup(); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(FakeResponse.Ok(config)); var sniffCall = FakeCalls.Sniff(fake); var seenPorts = new List<int>(); sniffCall.ReturnsLazily((Uri u, IRequestConfiguration c) => { seenPorts.Add(u.Port); return FakeResponse.Any(config, 403); }); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Bad(config)); fake.Provide<IConnectionConfigurationValues>(config); var e = Assert.Throws<ElasticsearchAuthorizationException>(() => FakeCalls.ProvideRealTranportInstance(fake)); sniffCall.MustHaveHappened(Repeated.Exactly.Once); getCall.MustNotHaveHappened(); } }
public void AConnectionMustBeMadeEvenIfAllNodesAreDead() { using (var fake = new AutoFake(callsDoNothing: true)) { //make sure we retry one more time then we have nodes //original call + 4 retries == 5 fake.Provide <IConnectionConfigurationValues>( new ConnectionConfiguration(_connectionPool) .MaximumRetries(4) ); //set up our GET to / to return 4 503's followed by a 200 var getCall = A.CallTo(() => fake.Resolve <IConnection>().GetSync(A <Uri> ._, A <IRequestConfiguration> ._)); getCall.ReturnsNextFromSequence( _ok ); var transport = this.ProvideTransport(fake); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.ReturnsNextFromSequence( _bad, _bad, _bad, _ok ); //setup client var client = fake.Resolve <ElasticsearchClient>(); //Do not throw because by miracle the 4th retry manages to give back a 200 //even if all nodes have been marked dead. Assert.DoesNotThrow(() => client.Info()); //original call + 4 retries == 5 getCall.MustHaveHappened(Repeated.Exactly.Once); //ping must have been send out 4 times to the 4 nodes being used for the first time pingCall.MustHaveHappened(Repeated.Exactly.Times(4)); } }
public void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes() { using (var fake = new AutoFake(callsDoNothing: true)) { //set up connection configuration that holds a connection pool //with '_uris' (see the constructor) fake.Provide<IConnectionConfigurationValues>(_config); //prove a real HttpTransport with its unspecified dependencies //as fakes this.ProvideTransport(fake); //set up fake for a call on IConnection.GetSync so that it always throws //an exception var getCall = FakeCalls.GetSyncCall(fake); getCall.Throws<Exception>(); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(_ok); //create a real ElasticsearchClient with it unspecified dependencies //as fakes var client = fake.Resolve<ElasticsearchClient>(); //we don't specify our own value so it should be up to the connection pool client.Settings.MaxRetries.Should().Be(null); //the default for the connection pool should be the number of nodes - 1; client.Settings.ConnectionPool.MaxRetries.Should().Be(_retries); //calling GET / should throw an OutOfNodesException because our fake //will always throw an exception Assert.Throws<MaxRetryException>(()=> client.Info()); //the GetSync method must in total have been called the number of nodes times. getCall.MustHaveHappened(Repeated.Exactly.Times(_retries + 1)); } }
public void SniffOnConnectionFaultCausesSniffOn503() { using (var fake = new AutoFake()) { var dateTimeProvider = fake.Resolve <IDateTimeProvider>(); var nowCall = A.CallTo(() => dateTimeProvider.Now()); nowCall.Returns(DateTime.UtcNow); var nodes = new[] { new Uri("http://localhost:9200") }; var connectionPool = new SniffingConnectionPool(nodes); var config = new ConnectionConfiguration(connectionPool) .SniffOnConnectionFault(); fake.Provide <IConnectionConfigurationValues>(config); var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider); var connection = fake.Resolve <IConnection>(); var sniffCall = FakeCalls.Sniff(fake, config, nodes); var getCall = FakeCalls.GetSyncCall(fake); getCall.ReturnsNextFromSequence( FakeResponse.Ok(config), //info 1 FakeResponse.Ok(config), //info 2 FakeResponse.Ok(config), //info 3 FakeResponse.Ok(config), //info 4 FakeResponse.Bad(config) //info 5 ); var client1 = fake.Resolve <ElasticsearchClient>(); client1.Info(); //info call 1 client1.Info(); //info call 2 client1.Info(); //info call 3 client1.Info(); //info call 4 Assert.Throws <MaxRetryException>(() => client1.Info()); //info call 5 sniffCall.MustHaveHappened(Repeated.Exactly.Once); nowCall.MustHaveHappened(Repeated.Exactly.Times(7)); } }
public void ShouldThrowAndNotRetrySniffOnStartup401() { using (var fake = new AutoFake(callsDoNothing: true)) { var uris = new[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9201"), new Uri("http://localhost:9202") }; var connectionPool = new SniffingConnectionPool(uris, randomizeOnStartup: false); var config = new ConnectionConfiguration(connectionPool) .SniffOnStartup(); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(FakeResponse.Ok(config)); var sniffCall = FakeCalls.Sniff(fake); var seenPorts = new List <int>(); sniffCall.ReturnsLazily((Uri u, IRequestConfiguration c) => { seenPorts.Add(u.Port); return(FakeResponse.Any(config, 401)); }); var getCall = FakeCalls.GetSyncCall(fake); getCall.Returns(FakeResponse.Bad(config)); fake.Provide <IConnectionConfigurationValues>(config); var e = Assert.Throws <ElasticsearchAuthenticationException>(() => FakeCalls.ProvideRealTranportInstance(fake)); sniffCall.MustHaveHappened(Repeated.Exactly.Once); getCall.MustNotHaveHappened(); } }
private ITransport ProvideTransport(AutoFake fake) { var param = new TypedParameter(typeof(IDateTimeProvider), null); return(fake.Provide <ITransport, Transport>(param)); }
public void Setup() { AutoFake = new AutoFake(); var configurationParams = new Dictionary <string, string> { { "MarvelComicsAPI:BaseURL", "http://gateway.marvel.com/v1/public/" }, { "MarvelComicsAPI:PublicKey", "f72ecc981b3848b2d7ae9973d0454131" }, { "MarvelComicsAPI:PrivateKey", "8614298176bdfa2ecff7a712cfdcb6e73bf1d4f9" }, }; config = new ConfigurationBuilder() .AddInMemoryCollection(configurationParams) .Build(); AutoFake.Provide(config); AutoFake.Provide(new Configuracao(new Uri(config.GetSection("MarvelComicsAPI:BaseURL").Value), config.GetSection("MarvelComicsAPI:PublicKey").Value, config.GetSection("MarvelComicsAPI:PrivateKey").Value)); relogio = A.Fake <Relogio>(); A.CallTo(() => relogio.DataAtual).Returns(DateTime.Now); A.CallTo(() => relogio.ObterStringTicks()).Returns(DateTime.Now.Ticks.ToString()); AutoFake.Provide(relogio); // o GetAsync precisa de uma resposta mockada do persogame // pra isso preciso cirar uma url no teste e mandar ela pro controller string ts = relogio.ObterStringTicks(); string publicKey = config.GetSection("MarvelComicsAPI:PublicKey").Value; string hash = GerarHash(ts, publicKey, config.GetSection("MarvelComicsAPI:PrivateKey").Value); nome = "Captain America"; url = config.GetSection("MarvelComicsAPI:BaseURL").Value + $"characters?ts={ts}&apikey={publicKey}&hash={hash}&" + $"name={Uri.EscapeUriString(nome)}"; // temos que saber o objeto de retorno da api pra poder mockar o retorno do objeto fake na implementacao concreta var conteudo = new StringContent(JsonSerializer.Serialize( new { data = new { results = new List <dynamic> { new { name = nome, description = Faker.Random.Words(20), thumbnail = new { path = Faker.Internet.Url(), extension = Faker.Random.String(3) }, urls = new List <dynamic> { new { url = Faker.Internet.Url() }, new { url = Faker.Internet.Url() } } } } } } )); // a resposta vem como um objeto serializado HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK) { Content = conteudo }; A.CallTo(() => AutoFake.Resolve <IHttpClient>().GetAsync(new Uri(url))).Returns(response); service = AutoFake.Resolve <PersonagemService>(); }
public void Should_Provide_Values() { var item = AutoFake.Provide(new MyItem()); ServiceProvider.GetRequiredService <MyItem>().Should().BeSameAs(item); }
public void Should_Populate_Optional_Parameters_When_Provided() { AutoFake.Provide <IItem>(new MyItem()); AutoFake.Resolve <Optional>().Item.Should().NotBeNull() .And.Match(z => !FakeItEasy.Fake.IsFake(z)); }
public void IfAllButOneConnectionDiesSubsequentRequestsMustUseTheOneAliveConnection() { using (var fake = new AutoFake(callsDoNothing: true)) { //Setting up a datetime provider so that we can measure which //nodes have been marked alive and dead. //we provide a different fake for the method call with the last node //as argument. var dateTimeProvider = fake.Resolve <IDateTimeProvider>(); A.CallTo(() => dateTimeProvider.Now()).Returns(DateTime.UtcNow); var markOthersDeadCall = A.CallTo(() => dateTimeProvider .DeadTime(A <Uri> .That.Not.Matches(u => u.Port == 9203), A <int> ._, A <int?> ._, A <int?> ._)); var markLastDead = A.CallTo(() => dateTimeProvider .DeadTime(A <Uri> .That.Matches(u => u.Port == 9203), A <int> ._, A <int?> ._, A <int?> ._)); var markOthersAliveCall = A.CallTo(() => dateTimeProvider .AliveTime(A <Uri> .That.Not.Matches(u => u.Port == 9203), A <int> ._)); var markLastAlive = A.CallTo(() => dateTimeProvider .AliveTime(A <Uri> .That.Matches(u => u.Port == 9203), A <int> ._)); markOthersDeadCall.Returns(DateTime.UtcNow.AddSeconds(60)); markLastAlive.Returns(new DateTime()); fake.Provide(dateTimeProvider); //Creating the connection pool making sure nodes are not randomized //So we are sure 9203 is that last node in the pool var connectionPool = new StaticConnectionPool( _uris, randomizeOnStartup: false, dateTimeProvider: dateTimeProvider ); var config = new ConnectionConfiguration(connectionPool); fake.Provide <IConnectionConfigurationValues>(config); // provide a simple fake for synchronous get var getCall = FakeCalls.GetSyncCall(fake); //The first three tries get a 503 causing the first 3 nodes to be marked dead //all the subsequent requests should be handled by 9203 which gives a 200 4 times getCall.ReturnsNextFromSequence( FakeResponse.Bad(config), FakeResponse.Bad(config), FakeResponse.Bad(config), FakeResponse.Ok(config), FakeResponse.Ok(config), FakeResponse.Ok(config), FakeResponse.Ok(config) ); //provide a transport with all the dependencies resolved var transport = this.ProvideTransport(fake); var pingCall = FakeCalls.PingAtConnectionLevel(fake); pingCall.Returns(_ok); //instantiate connection with faked dependencies var client = fake.Resolve <ElasticsearchClient>(); //We call the root for each node 4 times, eventhough the first 3 nodes //give back a timeout the default ammount of retries is 4 (each provided node) //and the last retry will hit our 9203 node. Assert.DoesNotThrow(() => client.Info()); //These calls should not hit the dead nodes and go straight to the active 9203 Assert.DoesNotThrow(() => client.Info()); Assert.DoesNotThrow(() => client.Info()); Assert.DoesNotThrow(() => client.Info()); //The last node should never be marked dead markLastDead.MustNotHaveHappened(); //the other nodes should never be marked alive markOthersAliveCall.MustNotHaveHappened(); //marking the other 3 nodes dead should only happen once for each markOthersDeadCall.MustHaveHappened(Repeated.Exactly.Times(3)); //every time a connection succeeds on a node it will be marked //alive therefor the last node should be marked alive 4 times markLastAlive.MustHaveHappened(Repeated.Exactly.Times(4)); } }
public async Task InProcess_SyncCommand(bool left) { using (var leftDirectory = new Infrastructure.TestDirectory()) using (var rightDirectory = new Infrastructure.TestDirectory()) { Infrastructure.TestDirectory.CreateDirectory(leftDirectory.CreateDirectory("Dir1"), "Dir2"); Infrastructure.TestDirectory.CreateDirectory(rightDirectory.CreateDirectory("Dir1"), "Dir2"); leftDirectory.CreateDirectory("Dir3"); rightDirectory.CreateDirectory("Dir3"); var containerBuilder = new ContainerBuilder(); containerBuilder.RegisterModule <TestAutofacRegisterModule>(); containerBuilder.RegisterType <SettingsRow>().As <ISettingsRow>(); containerBuilder.RegisterType <SynchronizedItems>().As <ISynchronizedItems>(); using (var fake = new AutoFake(builder: containerBuilder)) { var fakeItemFactory = A.Fake <IItemFactory>(); A.CallTo(() => fakeItemFactory.CreateDirectory(A <string> .Ignored, A <string[]> .Ignored)) .ReturnsLazily((string directoryPath, string[] excludedExtensions) => { return(new TestDirectory(directoryPath, fakeItemFactory, 1)); }); var fakeSettingsRow = A.Fake <ISettingsRow>(); A.CallTo(() => fakeSettingsRow.LeftDirectory).Returns(new SettingsDirectory(leftDirectory.FullPath)); A.CallTo(() => fakeSettingsRow.RightDirectory).Returns(new SettingsDirectory(rightDirectory.FullPath)); var fakeSynchronizedItemsStatusAndCommandsUpdater = A.Fake <ISynchronizedItemsStatusAndCommandsUpdater>(); A.CallTo(() => fakeSynchronizedItemsStatusAndCommandsUpdater .UpdateStatusesAndCommands(A <ISynchronizedItem> .Ignored, A <ISynchronizedItem> .Ignored)) .Invokes((ISynchronizedItem item1, ISynchronizedItem item2) => { item1.UpdateStatus(ItemStatusEnum.Equally); item2.UpdateStatus(ItemStatusEnum.Equally); }); fake.Provide(fakeSettingsRow); fake.Provide(fakeItemFactory); fake.Provide(fakeSynchronizedItemsStatusAndCommandsUpdater); var synchronizedItems = fake.Resolve <ISynchronizedItems>(); await synchronizedItems.Load(); // Загрузим, чтобы построилось дерево элементов. // А теперь запустим синхронизацию одного из элементов и проверим изменение признака InProcess. var childLevel1SynchronizedItems1 = synchronizedItems.ChildItems[0]; var processItem = left ? childLevel1SynchronizedItems1.LeftItem : childLevel1SynchronizedItems1.RightItem; processItem.SyncCommand.SetCommandAction(() => Task.Delay(4)); var syncTask = Task.Run(() => processItem.SyncCommand.Process()); await Task.Delay(2); // Чтобы признаки успели поменять значения. Assert.True(childLevel1SynchronizedItems1.InProcess); Assert.True(synchronizedItems.InProcess); // И процесс родителя должен обозначиться. Assert.True(childLevel1SynchronizedItems1.ChildItems[0].InProcess); // И процесс дочерних элементом. Assert.False(synchronizedItems.ChildItems[1].InProcess); // А эти элементы не при чём. syncTask.Wait(); // Ждём, пока завершится синхронизация. // А теперь всё обратно в false. Assert.False(childLevel1SynchronizedItems1.InProcess); Assert.False(synchronizedItems.InProcess); Assert.False(childLevel1SynchronizedItems1.ChildItems[0].InProcess); } } }
public void HostsReturnedBySniffAreVisited() { using (var fake = new AutoFake()) { var dateTimeProvider = fake.Resolve <IDateTimeProvider>(); var nowCall = A.CallTo(() => dateTimeProvider.Now()); nowCall.Returns(DateTime.UtcNow); var connectionPool = new SniffingConnectionPool(new[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9201") }, randomizeOnStartup: false); var config = new ConnectionConfiguration(connectionPool) .SniffOnConnectionFault(); fake.Provide <IConnectionConfigurationValues>(config); FakeCalls.ProvideDefaultTransport(fake); FakeCalls.PingAtConnectionLevel(fake) .Returns(FakeResponse.Ok(config)); var sniffCall = FakeCalls.Sniff(fake, config, new List <Uri>() { new Uri("http://localhost:9204"), new Uri("http://localhost:9203"), new Uri("http://localhost:9202"), new Uri("http://localhost:9201") }); var connection = fake.Resolve <IConnection>(); var seenNodes = new List <Uri>(); //var getCall = FakeResponse.GetSyncCall(fake); var getCall = A.CallTo(() => connection.GetSync( A <Uri> .That.Not.Matches(u => u.AbsolutePath.StartsWith("/_nodes")), A <IRequestConfiguration> ._)); getCall.ReturnsNextFromSequence( FakeResponse.Ok(config), //info 1 FakeResponse.Bad(config), //info 2 FakeResponse.Ok(config), //info 2 retry FakeResponse.Ok(config), //info 3 FakeResponse.Ok(config), //info 4 FakeResponse.Ok(config), //info 5 FakeResponse.Ok(config), //info 6 FakeResponse.Ok(config), //info 7 FakeResponse.Ok(config), //info 8 FakeResponse.Ok(config) //info 9 ); getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u)); var client1 = fake.Resolve <ElasticsearchClient>(); client1.Info(); //info call 1 client1.Info(); //info call 2 client1.Info(); //info call 3 client1.Info(); //info call 4 client1.Info(); //info call 5 client1.Info(); //info call 6 client1.Info(); //info call 7 client1.Info(); //info call 8 client1.Info(); //info call 9 sniffCall.MustHaveHappened(Repeated.Exactly.Once); seenNodes.Should().NotBeEmpty().And.HaveCount(10); seenNodes[0].Port.Should().Be(9200); seenNodes[1].Port.Should().Be(9201); //after sniff seenNodes[2].Port.Should().Be(9202, string.Join(",", seenNodes.Select(n => n.Port))); seenNodes[3].Port.Should().Be(9204); seenNodes[4].Port.Should().Be(9203); seenNodes[5].Port.Should().Be(9202); seenNodes[6].Port.Should().Be(9201); } }
protected TService The <TService, TImplementation>() { return(FakeResolver.Provide <TService, TImplementation>()); }
public DryIocBuilderTests(ITestOutputHelper outputHelper) : base(outputHelper) { AutoFake.Provide <IDictionary <object, object?> >(new ServiceProviderDictionary()); }
public void AllNodesMustBeTriedOnce() { using (var fake = new AutoFake(callsDoNothing: true)) { //set up client with fakes fake.Provide<IConnectionConfigurationValues>(_config); var connection = fake.Resolve<NoopConnection>(); fake.Provide<IConnection>(connection); this.ProvideTransport(fake); //provide a unique fake for each node. var calls = _uris.Select(u => A.CallTo(()=> fake.Resolve<IUriObserver>() .Observe(A<Uri>.That.Matches(uu=>uu.Port == u.Port))) ).ToList(); //all of our fakes throw an exception foreach (var c in calls) c.Throws<Exception>(); var client = fake.Resolve<ElasticsearchClient>(); Assert.Throws<OutOfNodesException>(()=> client.Info()); //make sure we've observed an attempt on all the nodes foreach (var call in calls) call.MustHaveHappened(Repeated.Exactly.Once); } }
private void ProvideTransport(AutoFake fake) { var param = new TypedParameter(typeof(IDateTimeProvider), null); fake.Provide<ITransport, Transport>(param); }