示例#1
0
        public void Booking_confirm_should_take_two_different_payments_suggested_by_the_price_calculator()
        {
            // arrange
            using var fake = new AutoFake();
            var booking         = fake.Resolve <Booking>();
            var priceCalculator = fake.Resolve <IPriceCalculator>();
            var paymentGateway  = fake.Resolve <IPaymentGateway>();

            var price1 = new Price {
                Amount = 100, VatAmount = 5m
            };
            var price2 = new Price {
                Amount = 50, VatAmount = 2.5m
            };

            A.CallTo(() => priceCalculator.CalculatePrice())
            .ReturnsNextFromSequence(price1, price2);

            // act
            booking.Confirm6();

            // assert
            A.CallTo(() => paymentGateway.CapturePayment(price2.Amount, price2.VatAmount)).MustHaveHappenedOnceExactly();
            A.CallTo(() => paymentGateway.CapturePayment(price1.Amount, price1.VatAmount)).MustHaveHappenedOnceExactly();
        }
        public void HardRetryLimitTakesPrecedenceOverNumberOfNodes()
        {
            using (var fake = new AutoFake(callsDoNothing: true))
            {
                //setup config values with a hight retry count
                fake.Provide <IConnectionConfigurationValues>(
                    new ConnectionConfiguration(_connectionPool)
                    .MaximumRetries(7)
                    );
                var getCall = A.CallTo(() =>
                                       fake.Resolve <IConnection>().GetSync(A <Uri> ._, A <IRequestConfiguration> ._));
                getCall.Throws <Exception>();

                var transport = this.ProvideTransport(fake);
                var pingCall  = FakeCalls.PingAtConnectionLevel(fake);
                pingCall.Returns(_ok);

                var client = fake.Resolve <ElasticsearchClient>();

                Assert.Throws <MaxRetryException>(() => client.Info());

                //We want to see 8 attempt to do a GET on /
                //(original call + retry of 7 == 8)
                getCall.MustHaveHappened(Repeated.Exactly.Times(8));
            }
        }
示例#3
0
		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 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 <MaxRetryException>(() => client.Info());

                //make sure we've observed an attempt on all the nodes
                foreach (var call in calls)
                {
                    call.MustHaveHappened(Repeated.Exactly.Once);
                }
            }
        }
示例#5
0
        public void Task2_CreateNewUserShouldCallUserRepository()
        {
            const string userName = "******";
            const string email    = "*****@*****.**";
            const int    age      = 42;

            using var fake = new AutoFake();

            var usersController = fake.Resolve <UsersController>();

            var userCreateData = new UserCreate
            {
                Name  = userName,
                Email = email,
                Age   = age
            };

            usersController.CreateNewUser(userCreateData);

            var fakeUsersRepository = fake.Resolve <IUsersRepository>();

            var foundCall = TestUtilities.GetMethodCall(() => fakeUsersRepository.CreateNewUser("", "", 0));

            Assert.IsNotNull(foundCall, CreateNewUserNotCalledError);

            Assert.That.All(
                () => Assert.AreEqual(userName, foundCall.Get <string>("name"), UserNameNotPassedError),
                () => Assert.AreEqual(email, foundCall.Get <string>("email"), UserEmailNotPassedError),
                () => Assert.AreEqual(42, foundCall.Get <int>("age"), UserAgeNotPassedError)
                );
        }
        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(
                    _bad,
                    _bad,
                    _bad,
                    _bad,
                    _ok
                    );
                var transport = this.ProvideTransport(fake);
                var pingCall  = FakeCalls.PingAtConnectionLevel(fake);
                pingCall.Returns(_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.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 InterceptTest(bool hasContext, string method, int initialDepth, bool proceedCalled, string durableInvocation)
        {
            using (var fake = new AutoFake())
            {
                DurableInterceptor.Context.Value = hasContext ? new DurableContext {
                    OrchestrationContext = fake.Resolve <IDurableOrchestrationContext>()
                } : null;

                var invocation = fake.Resolve <IInvocation>();

                A.CallTo(() => invocation.Method).Returns(this.GetType().GetMethod(method));

                var durableInterceptor = fake.Resolve <DurableInterceptor>();

                (durableInterceptor.GetType()
                 .GetMethod("get_Depth", BindingFlags.NonPublic | BindingFlags.Static)
                 .Invoke(durableInterceptor, null) as AsyncLocal <int>
                ).Value = initialDepth;

                durableInterceptor.Intercept(invocation);

                A.CallTo(() => invocation.Proceed()).MustHaveHappened(proceedCalled ? 1 : 0, Times.Exactly);

                if (!string.IsNullOrWhiteSpace(durableInvocation))
                {
                    Fake.GetCalls(DurableInterceptor.Context.Value.OrchestrationContext)
                    .Any(p => p.Method.Name == durableInvocation)
                    .Should().BeTrue();
                }
            }
        }
示例#8
0
        public void Task3_CreateNewUserShouldCallStoreWithUserData()
        {
            using var autoFake = new AutoFake();

            var fakeDocumentStoreFactory = autoFake.Resolve <IDocumentStoreFactory>();
            var fakeDocumentStore        = A.Fake <IDocumentStore>();

            A.CallTo(() => fakeDocumentStoreFactory.Store).Returns(fakeDocumentStore);
            var fakeDocumentSession = A.Fake <IDocumentSession>();

            A.CallTo(() => fakeDocumentStore.OpenSession(A <DocumentTracking> ._, A <IsolationLevel> ._))
            .Returns(fakeDocumentSession);

            var usersRepository = autoFake.Resolve <UsersRepository>();

            usersRepository.CreateNewUser("user name", "*****@*****.**", 42);

            var methodCall = TestUtilities.GetMethodCall(() => fakeDocumentSession.Store(new User[0]));

            Assert.IsNotNull(methodCall, StoreNotCalledError);

            var users = methodCall.Get <User[]>("entities");

            Assert.IsNotNull(users, UserWasNotPassedToStoreError);
            Assert.AreEqual(1, users.Length, UserWasNotPassedToStoreError);

            User createdUser = users[0];

            Assert.That.All(
                () => Assert.AreEqual("user name", createdUser.Name, WrongUserArgumentsPassedToDbError),
                () => Assert.AreEqual("*****@*****.**", createdUser.Email, WrongUserArgumentsPassedToDbError),
                () => Assert.AreEqual(42, createdUser.Age, WrongUserArgumentsPassedToDbError)
                );
        }
示例#9
0
        public void HelloWorld3_approve()
        {
            using (var fake = new AutoFake())
            {
                var provider = fake.Resolve <IServiceLocator>();

                var actionRepository = new InMemoryRepository <ActionDef>(new List <ActionDef>());
                A.CallTo(() => provider.GetInstance <IRepository <ActionDef> >()).Returns(actionRepository);
                ServiceLocator.SetLocatorProvider(() => provider);

                ProcessDefinition processDefinition = ProcessDefinitionFactory.getHelloWorld3();

                var        delegationHelper = fake.Resolve <IDelegationHelper>();
                Transition transition       = processDefinition.Nodes.Single(s => s is Decision).LeavingTransitions.Single(l => l.To is EndState);
                A.CallTo(delegationHelper).WithReturnType <Transition>().Returns(transition);
                A.CallTo(() => provider.GetInstance <IDelegationHelper>()).Returns(delegationHelper);

                ExecutionContext executionContext = new ExecutionContext(new User("ae"), processDefinition);

                ProcessInstance processInstance = executionContext.StartProcess();
                Assert.AreEqual(2, executionContext.Flow.AttributeInstances.Count);

                IDictionary <string, object> attributeValues = new Dictionary <string, object>();
                attributeValues.Add("evaluation result", "approve");
                executionContext.PerformActivity(attributeValues);

                var endState = processDefinition.Nodes.Single(q => q is EndState);
                Assert.AreEqual(endState, processInstance.RootFlow.Node);
            }
        }
示例#10
0
        public void Task4_GetUserByIdShouldCallLoad()
        {
            using var autoFake = new AutoFake();

            var user = new User
            {
                Id    = 1,
                Name  = "user1",
                Age   = 42,
                Email = "*****@*****.**"
            };

            var fakeDocumentStoreFactory = autoFake.Resolve <IDocumentStoreFactory>();
            var fakeDocumentStore        = A.Fake <IDocumentStore>();

            A.CallTo(() => fakeDocumentStoreFactory.Store).Returns(fakeDocumentStore);
            var fakeSession = A.Fake <IQuerySession>();

            A.CallTo(() => fakeDocumentStore.QuerySession()).Returns(fakeSession);
            A.CallTo(() => fakeSession.Load <User>(1)).Returns(user);

            var usersRepository = autoFake.Resolve <UsersRepository>();

            var userById = usersRepository.GetUserById(1);

            var fakeObjectCall = TestUtilities.GetMethodCall(() => fakeSession.Load <User>(0));

            Assert.IsNotNull(fakeObjectCall, QuerySessionLoadNotCalledError);
            Assert.AreEqual(1, fakeObjectCall.Arguments.Get <int>(0), IdNotPassedToQueryError);
            Assert.AreEqual(user, userById, UserNotReturnedFromGetUserByIdError);
        }
 private static IMppPresentatie PreparePresentation(AutoFake fakeScope, string fileName)
 {
     var app = fakeScope.Resolve<IMppApplication>();
     A.CallTo(() => fakeScope.Resolve<IMppFactory>().GetApplication()).Returns(app);
     var pres = fakeScope.Resolve<IMppPresentatie>();
     A.CallTo(() => app.Open(fileName, true)).Returns(pres);
     return pres;
 }
示例#12
0
        public void Setup()
        {
            var mapper = new AutoMapperConfig().RegisterMappings().CreateMapper();

            _autoFakeContainer = new AutoFake();

            _sut = new CustomerController(_autoFakeContainer.Resolve <ICustomerRepository>(), mapper,
                                          _autoFakeContainer.Resolve <HttpContextBase>());
        }
        public static AutoFake WithFakeHttpClient(this AutoFake autoFake, string baseAddress)
        {
            A.CallTo(() => autoFake.Resolve <ILocalhostAddressLocator>().BaseAddress)
            .Returns(baseAddress);

            autoFake.Provide <IHttpClientFactory>(new FakeHttpClientFactory(autoFake.Resolve <ILocalhostAddressLocator>()));

            return(autoFake);
        }
示例#14
0
        public void ByDefaultAbstractTypesAreResolvedToTheSameSharedInstance()
        {
            using (var fake = new AutoFake())
            {
                var bar1 = fake.Resolve<IBar>();
                var bar2 = fake.Resolve<IBar>();

                Assert.AreSame(bar1, bar2);
            }
        }
        public void ByDefaultAbstractTypesAreResolvedToTheSameSharedInstance()
        {
            using (var fake = new AutoFake())
            {
                var bar1 = fake.Resolve <IBar>();
                var bar2 = fake.Resolve <IBar>();

                Assert.Same(bar1, bar2);
            }
        }
        public void ByDefaultConcreteTypesAreResolvedToTheSameSharedInstance()
        {
            using (var fake = new AutoFake())
            {
                var baz1 = fake.Resolve <Baz>();
                var baz2 = fake.Resolve <Baz>();

                Assert.Same(baz1, baz2);
            }
        }
示例#17
0
        public void ByDefaultConcreteTypesAreResolvedToTheSameSharedInstance()
        {
            using (var fake = new AutoFake())
            {
                var baz1 = fake.Resolve<Baz>();
                var baz2 = fake.Resolve<Baz>();

                Assert.AreSame(baz1, baz2);
            }
        }
        public void AllNodesWillBeMarkedDead()
        {
            using (var fake = new AutoFake(callsDoNothing: true))
            {
                //set up a fake datetimeprovider
                var dateTimeProvider = fake.Resolve <IDateTimeProvider>();
                fake.Provide(dateTimeProvider);
                //create a connectionpool that uses the fake datetimeprovider
                var connectionPool = new StaticConnectionPool(
                    _uris,
                    dateTimeProvider: dateTimeProvider
                    );
                var config = new ConnectionConfiguration(connectionPool);
                fake.Provide <IConnectionConfigurationValues>(config);

                //Now() on the fake still means Now()
                A.CallTo(() => dateTimeProvider.Now()).Returns(DateTime.UtcNow);
                //Set up individual mocks for each DeadTime(Uri uri,...) call
                //where uri matches one of the node ports
                var calls = _uris.Select(u =>
                                         A.CallTo(() => dateTimeProvider.DeadTime(
                                                      A <Uri> .That.Matches(uu => uu.Port == u.Port),
                                                      A <int> ._, A <int?> ._, A <int?> ._
                                                      ))).ToList();

                //all the fake mark dead calls return 60 seconds into the future
                foreach (var call in calls)
                {
                    call.Returns(DateTime.UtcNow.AddSeconds(60));
                }

                //When we do a GET on / we always recieve a 503
                var getCall = A.CallTo(() => fake.Resolve <IConnection>().GetSync(A <Uri> ._, A <IRequestConfiguration> ._));
                getCall.Returns(_bad);

                var transport = this.ProvideTransport(fake);
                var pingCall  = FakeCalls.PingAtConnectionLevel(fake);
                pingCall.Returns(_ok);
                var client = fake.Resolve <ElasticsearchClient>();

                //Since we always get a 503 we should see an out of nodes exception
                Assert.Throws <MaxRetryException>(() => client.Info());

                pingCall.MustHaveHappened(Repeated.Exactly.Times(4));

                //The call should be tried on all the nodes
                getCall.MustHaveHappened(Repeated.Exactly.Times(4));

                //We should see each individual node being marked as dead
                foreach (var call in calls)
                {
                    call.MustHaveHappened(Repeated.Exactly.Once);
                }
            }
        }
示例#19
0
        public static ITransport ProvideRealTranportInstance(AutoFake fake, IDateTimeProvider dateTimeProvider = null)
        {
            var connection      = fake.Resolve <IConnection>();
            var config          = fake.Resolve <IConnectionConfigurationValues>();
            var param           = new TypedParameter(typeof(IDateTimeProvider), dateTimeProvider);
            var serializerParam = new TypedParameter(typeof(IElasticsearchSerializer), null);

            return(new Transport(
                       config, connection,
                       serializerParam.Value as IElasticsearchSerializer,
                       param.Value as IDateTimeProvider));
        }
        public void IfAConnectionComesBackToLifeOnItsOwnItShouldBeMarked()
        {
            using (var fake = new AutoFake(callsDoNothing: true))
            {
                //Setting up a datetime provider so that can track dead/alive marks
                var dateTimeProvider = fake.Resolve <IDateTimeProvider>();
                A.CallTo(() => dateTimeProvider.Now()).Returns(DateTime.UtcNow);
                var markDeadCall  = A.CallTo(() => dateTimeProvider.DeadTime(A <Uri> ._, A <int> ._, A <int?> ._, A <int?> ._));
                var markAliveCall = A.CallTo(() => dateTimeProvider.AliveTime(A <Uri> ._, A <int> ._));
                markDeadCall.Returns(DateTime.UtcNow.AddSeconds(60));
                markAliveCall.Returns(new DateTime());
                fake.Provide(dateTimeProvider);
                var connectionPool = new StaticConnectionPool(
                    _uris,
                    dateTimeProvider: dateTimeProvider);

                //set retries to 4
                fake.Provide <IConnectionConfigurationValues>(
                    new ConnectionConfiguration(connectionPool)
                    .MaximumRetries(4)
                    );

                //fake getsync handler that return a 503 4 times and then a 200
                //this will cause all 4 nodes to be marked dead on the first client call
                var getCall = FakeCalls.GetSyncCall(fake);
                getCall.ReturnsNextFromSequence(
                    _bad,
                    _bad,
                    _bad,
                    _bad,
                    _ok
                    );
                //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>();

                //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 is 5
                getCall.MustHaveHappened(Repeated.Exactly.Times(5));
                //4 nodes must be marked dead
                markDeadCall.MustHaveHappened(Repeated.Exactly.Times(4));
                //atleast one of them sprung back to live so markAlive must be called once
                markAliveCall.MustHaveHappened(Repeated.Exactly.Times(1));
            }
        }
示例#21
0
        public void SniffIsCalledAfterItHasGoneOutOfDate_NotWhenItSeesA503()
        {
            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(10),      //info call 4
                    DateTime.UtcNow.AddMinutes(12)       //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))
                                     .ExposeRawResponse();
                fake.Provide <IConnectionConfigurationValues>(config);
                var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider);

                var pingCall = FakeCalls.PingAtConnectionLevel(fake);
                pingCall.Returns(FakeResponse.Ok(config));

                var sniffCall = FakeCalls.Sniff(fake, config, uris);
                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),                     //sniff
                    FakeResponse.Ok(config),                     //info 4
                    FakeResponse.Bad(config)                     //info 5
                    );

                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.Once);
                nowCall.MustHaveHappened(Repeated.Exactly.Times(7));

                //var nowCall = A.CallTo(() => fake.Resolve<IDateTimeProvider>().Sniff(A<Uri>._, A<int>._));
            }
        }
示例#22
0
        public async Task Should_FindAllYamlFiles()
        {
            // Arrange

            var fs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { @"c:\root\shortcuts\vscode\shortcuts.yml", new MockFileData(TestData.OneContext1Shortcut()) },
                { @"c:\root\shortcuts\vs\shortcuts.yml", new MockFileData(TestData.TwoContext2Shortcuts()) },
                { @"c:\root\shortcuts\notyml\shortcuts.json", new MockFileData("") },
                { @"c:\not-root\shortcuts\xy\shortcuts.yml", new MockFileData("") },
            });

            _auto.Provide <IFileSystem>(fs);

            var handler = _auto.Resolve <LoadRawShortcutsFromFilesRequestHandler>();
            var request = new LoadRawShortcutsFromFiles()
            {
                SourceDirectory = @"C:\root\shortcuts\"
            };

            // Act
            var result = await handler.Handle(request, CancellationToken.None);


            // Assert
            result.Should().HaveCount(2);
        }
示例#23
0
        public void Task2_CreateNewUserShouldReturnCreatedUserId()
        {
            using var fake = new AutoFake();

            var fakeUsersRepository = fake.Resolve <IUsersRepository>();

            A.CallTo(() => fakeUsersRepository.CreateNewUser(A <String> ._, A <string> ._, A <int> ._))
            .Returns(123);

            var usersController = fake.Resolve <UsersController>();

            var actual = usersController.CreateNewUser(new UserCreate());

            Assert.AreEqual(123, actual, UserIdNotReturnedError);
        }
示例#24
0
        public void Task5_DeleteUserShouldCallUsersRepository()
        {
            using var fake = new AutoFake();

            var usersController = fake.Resolve <UsersController>();

            usersController.Delete(100);

            var fakeUsersRepository = fake.Resolve <IUsersRepository>();

            var fakeObjectCall = TestUtilities.GetMethodCall(() => fakeUsersRepository.DeleteUser(0));

            Assert.IsNotNull(fakeObjectCall, DeleteUserWasNotCalledError);
            Assert.AreEqual(100, fakeObjectCall.Arguments.Get <int>(0), DeleteCalledWithWrongIdError);
        }
示例#25
0
        public void Test()
        {
            // Arrange
            using var fake = new AutoFake();

            A.CallTo(() => fake.Resolve <INameProvider>().GetName()).Returns("A Name");

            // Act
            var sut = fake.Resolve <MyClassAuto>();

            sut.DoGreeting();

            // Assert
            A.CallTo(() => fake.Resolve <IGreetingService>().Greet("A Name")).MustHaveHappened();
        }
示例#26
0
        public void SniffOnConnectionFaultCausesSniffOn503()
        {
            using (var fake = new AutoFake())
            {
                var dateTimeProvider = fake.Resolve <IDateTimeProvider>();
                var nowCall          = A.CallTo(() => dateTimeProvider.Now());
                nowCall.Invokes(() =>
                {
                });
                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 sniffNewNodes = new[]
                {
                    new Uri("http://localhost:9200"),
                    new Uri("http://localhost:9201")
                };
                var pingCall = FakeCalls.PingAtConnectionLevel(fake);
                pingCall.Returns(FakeResponse.Ok(config));

                var sniffCall = FakeCalls.Sniff(fake, config, sniffNewNodes);
                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(8));
            }
        }
            public void Application_Opened()
            {
                using (var fake = new AutoFake())
                {
                    var app = fake.Resolve<IMppApplication>();
                    A.CallTo(() => fake.Resolve<IMppFactory>().GetApplication()).Returns(app);
                    var sut = fake.Resolve<mppt.PowerpointFunctions>();
                    var dependendFiles = A.Fake<IBuilderDependendFiles>();
                    A.CallTo(() => dependendFiles.FullTemplateTheme).Returns("\testbestand.ppt");
                    sut.PreparePresentation(GetEmptyLiturgie(), A.Fake<IBuilderBuildSettings>(), A.Fake<IBuilderBuildDefaults>(), dependendFiles, null);

                    sut.GeneratePresentation();

                    A.CallTo(() => app.Open(dependendFiles.FullTemplateTheme, true)).MustHaveHappened();
                }
            }
示例#28
0
        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 FailEarlyIfTimeoutIsExhausted_Async()
		{
			using (var fake = new AutoFake())
			{
				var dateTimeProvider = ProvideDateTimeProvider(fake);
				var config = ProvideConfiguration(dateTimeProvider);
				var connection = ProvideConnection(fake, config, dateTimeProvider);
				
				var getCall = FakeCalls.GetCall(fake);
				var ok = Task.FromResult(FakeResponse.Ok(config));
				var bad = Task.FromResult(FakeResponse.Bad(config));
				getCall.ReturnsNextFromSequence(
					bad,  
					bad,  
					ok 
				);
				
				var seenNodes = new List<Uri>();
				getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));

				var pingCall = FakeCalls.PingAtConnectionLevelAsync(fake);
				pingCall.Returns(ok);

				var client1 = fake.Resolve<ElasticsearchClient>();
				//event though the third node should have returned ok, the first 2 calls took a minute
				var e = Assert.Throws<MaxRetryException>(async () => await client1.InfoAsync());
				e.Message.Should()
					.StartWith("Retry timeout 00:01:00 was hit after retrying 1 times:");

				IElasticsearchResponse response = null;
				Assert.DoesNotThrow(async () => response = await client1.InfoAsync() );
				response.Should().NotBeNull();
				response.Success.Should().BeTrue();
			}
		}
示例#30
0
		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));

			}
		}
示例#31
0
    public void Should_Inject_LoggerFactory()
    {
        var test = AutoFake.Resolve <LoggerFactoryImpl>();

        test.Write();
        A.CallTo(() => AutoFake.Resolve <ITestOutputHelper>().WriteLine(A <string> ._)).MustHaveHappened();
    }
        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);
            }
        }
示例#33
0
        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);
            }
        }
示例#34
0
        public void MustCallDelegatesOnBuild()
        {
            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);

            martenBuilder.UseDirtyTrackedSession();

            var serviceProvider = servicesBuilder.Build();
            var options         = serviceProvider.GetRequiredService <IOptions <StoreOptions> >().Value;

            A.CallTo(() => configurationDelegate(options))
            .MustHaveHappened(Repeated.Exactly.Once)
            .Then(A.CallTo(() => componentConfigurationDelegate(A <IServiceProvider> ._, options))
                  .MustHaveHappened(Repeated.Exactly.Once));
        }
        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);

            }
        }
示例#36
0
    public void Should_Fail_If_Container_Is_Touched_When_Building()
    {
        var    access = AutoFake.Resolve <DoubleAccess>();
        Action a      = () => access.Self.Resolve <IContainer>();

        a.Should().Throw <TestBootstrapException>();
    }
示例#37
0
        public void IgnoreNonExistentItems()
        {
            AutoFake.Provide <IDictionary <object, object> >(new Dictionary <object, object>());
            var servicesBuilder = AutoFake.Resolve <ServicesBuilder>();

            servicesBuilder[string.Empty].Should().BeNull();
        }
		public void IfResponseIsKnowError_DoNotRetry_ThrowServerException(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.PingAtConnectionLevel(fake);
				pingCall.Returns(FakeResponse.Ok(connectionConfiguration));

				var getCall = FakeCalls.GetSyncCall(fake);
				getCall.Returns(FakeResponse.Any(connectionConfiguration, status, response: response));

				var client = fake.Resolve<ElasticsearchClient>();

				var e = Assert.Throws<ElasticsearchServerException>(()=>client.Info());
				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 void SendsNotificationThrough_OnBuild_Observable_ForAutofac()
        {
            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 observerContainer   = A.Fake <IObserver <IContainer> >();
            var observerApplication = A.Fake <IObserver <ILifetimeScope> >();
            var observerSystem      = A.Fake <IObserver <ILifetimeScope> >();

            servicesBuilder.OnContainerBuild.Subscribe(observerContainer);
            servicesBuilder.OnBuild.Subscribe(observer);

            var container = servicesBuilder.Build();

            A.CallTo(() => observer.OnNext(A <IServiceProvider> ._)).MustHaveHappenedOnceExactly();
            A.CallTo(() => observerContainer.OnNext(container)).MustHaveHappenedOnceExactly();
        }
示例#40
0
 public void ByDefaultFakesAreNotStrict()
 {
     using (var fake = new AutoFake())
     {
         var foo = fake.Resolve<Foo>();
         Assert.DoesNotThrow(() => foo.Go());
     }
 }
示例#41
0
		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));

			}
		}
示例#42
0
 public void TestContext()
 {
     using (var fake = new AutoFake(false, false, false, null, AutofacInstaller.Register()))
     {
         //var listValueModel = GetListDataInCsv();
         var sawEditorPullService = fake.Resolve<ICornerstoneListsRepository>();
         var result = sawEditorPullService.GetListCornerstoneLists();
         Console.WriteLine("List WorkerId: {0}", string.Join(",", result.Select(x => x.Id)));
     }
 }
		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 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 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 Application_Saved(string saveAsFileName)
            {
                using (var fake = new AutoFake())
                {
                    var dependendFiles = A.Fake<IBuilderDependendFiles>();
                    A.CallTo(() => dependendFiles.FullTemplateTheme).Returns("\testbestand.ppt");
                    var pres = PreparePresentation(fake, dependendFiles.FullTemplateTheme);
                    var sut = fake.Resolve<mppt.PowerpointFunctions>();
                    sut.PreparePresentation(GetEmptyLiturgie(), A.Fake<IBuilderBuildSettings>(), A.Fake<IBuilderBuildDefaults>(), dependendFiles, saveAsFileName);

                    sut.GeneratePresentation();

                    A.CallTo(() => pres.OpslaanAls(saveAsFileName)).MustHaveHappened();
                }
            }
示例#47
0
		public void DeadNodesAreNotVisited_AndPingedAppropiately()
		{
			using (var fake = new AutoFake())
			{
				var dateTimeProvider = ProvideDateTimeProvider(fake);
				var config = ProvideConfiguration(dateTimeProvider);
				var connection = ProvideConnection(fake, config);

				var getCall = FakeCalls.GetSyncCall(fake);
				var ok = FakeResponse.Ok(config);
				var bad = FakeResponse.Bad(config);
				getCall.ReturnsNextFromSequence(
					ok,  //info 1 - 9204
					bad, //info 2 - 9203 DEAD
					ok,  //info 2 retry - 9202
					ok,  //info 3 - 9201
					ok,  //info 4 - 9204
					ok,  //info 5 - 9202
					ok,  //info 6 - 9201
					ok,  //info 7 - 9204
					ok,  //info 8 - 9203 (Now > Timeout)
					ok   //info 9 - 9202
				);
				
				var seenNodes = new List<Uri>();
				getCall.Invokes((Uri u, IRequestConnectionConfiguration o) => seenNodes.Add(u));

				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
				pingCall.Returns(ok);

				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

				AssertSeenNodesAreInExpectedOrder(seenNodes);

				//4 nodes first time usage + 1 time after the first time 9203 came back to live
				pingCall.MustHaveHappened(Repeated.Exactly.Times(5));

			}
		}
		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 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 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);
		}
示例#53
0
		public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> Sniff(
			AutoFake fake, 
			IConnectionConfigurationValues configurationValues = null,
			IList<Uri> nodes = null)
		{
			var sniffCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(
				A<Uri>.That.Matches(IsSniffUrl()), 
				A<IRequestConfiguration>._));
			if (nodes == null) return sniffCall;
			sniffCall.ReturnsLazily(()=>
			{
				
				var stream = SniffResponse(nodes);
				var response = FakeResponse.Ok(configurationValues, "GET", "/_nodes/_all/clear", stream);
				return response;
			});

			return sniffCall;
		}
示例#54
0
		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);
			}
		}
        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);
            }
        }
示例#57
0
		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 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 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 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);
			}
		}