Exemplo n.º 1
0
        public InboundConnectorTests()
        {
            var services = new ServiceCollection();

            _testSubscriber    = new TestSubscriber();
            _inboundSubscriber = new WrappedInboundMessageSubscriber();
            _someUnhandledMessageSubscriber = new SomeUnhandledMessageSubscriber();

            services.AddSingleton <ILoggerFactory, NullLoggerFactory>();
            services.AddSingleton(typeof(ILogger <>), typeof(NullLogger <>));

            services
            .AddSilverback()
            .AddSingletonSubscriber(_testSubscriber)
            .AddSingletonSubscriber(_inboundSubscriber)
            .AddSingletonSubscriber(_someUnhandledMessageSubscriber)
            .WithConnectionTo <TestBroker>(options => options
                                           .AddChunkStore <InMemoryChunkStore>());

            var serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions
            {
                ValidateScopes = true
            });

            _broker             = (TestBroker)serviceProvider.GetService <IBroker>();
            _connector          = new InboundConnector(_broker, serviceProvider);
            _errorPolicyBuilder = new ErrorPolicyBuilder(serviceProvider, NullLoggerFactory.Instance);
        }
        public void Retry_Default_RetryPolicyCreated()
        {
            var builder = new ErrorPolicyBuilder();

            builder.Retry();
            var policy = builder.Build();

            policy.Should().BeOfType <RetryErrorPolicy>();
        }
        public void Skip_Default_SkipPolicyCreated()
        {
            var builder = new ErrorPolicyBuilder();

            builder.Skip();
            var policy = builder.Build();

            policy.Should().BeOfType <SkipMessageErrorPolicy>();
        }
        public void Stop_Default_StopPolicyCreated()
        {
            var builder = new ErrorPolicyBuilder();

            builder.Stop();
            var policy = builder.Build();

            policy.Should().BeOfType <StopConsumerErrorPolicy>();
        }
        public void Retry_WithConfiguration_RetryPolicyCreatedAndConfigurationApplied()
        {
            var builder = new ErrorPolicyBuilder();

            builder.Retry(retryPolicy => retryPolicy.MaxFailedAttempts(42));
            var policy = builder.Build();

            policy.Should().BeOfType <RetryErrorPolicy>();
            policy.As <RetryErrorPolicy>().MaxFailedAttemptsCount.Should().Be(42);
        }
        public void Skip_WithConfiguration_SkipPolicyCreatedAndConfigurationApplied()
        {
            var builder = new ErrorPolicyBuilder();

            builder.Skip(skipPolicy => skipPolicy.ApplyTo <TimeoutException>());
            var policy = builder.Build();

            policy.Should().BeOfType <SkipMessageErrorPolicy>();
            policy.As <SkipMessageErrorPolicy>().IncludedExceptions.Should()
            .BeEquivalentTo(typeof(TimeoutException));
        }
        public void Stop_WithConfiguration_StopPolicyCreatedAndConfigurationApplied()
        {
            var builder = new ErrorPolicyBuilder();

            builder.Stop(stopPolicy => stopPolicy.Exclude <InvalidOperationException>());
            var policy = builder.Build();

            policy.Should().BeOfType <StopConsumerErrorPolicy>();
            policy.As <StopConsumerErrorPolicy>().ExcludedExceptions.Should()
            .BeEquivalentTo(typeof(InvalidOperationException));
        }
        public void Move_Endpoint_MovePolicyCreated()
        {
            var builder  = new ErrorPolicyBuilder();
            var endpoint = TestProducerEndpoint.GetDefault();

            builder.Move(endpoint);
            var policy = builder.Build();

            policy.Should().BeOfType <MoveMessageErrorPolicy>();
            policy.As <MoveMessageErrorPolicy>().Endpoint.Should().BeSameAs(endpoint);
        }
        public void Move_EndpointWithConfiguration_SkipPolicyCreatedAndConfigurationApplied()
        {
            var builder  = new ErrorPolicyBuilder();
            var endpoint = TestProducerEndpoint.GetDefault();

            builder.Move(endpoint, movePolicy => movePolicy.MaxFailedAttempts(42));
            var policy = builder.Build();

            policy.Should().BeOfType <MoveMessageErrorPolicy>();
            policy.As <MoveMessageErrorPolicy>().Endpoint.Should().BeSameAs(endpoint);
            policy.As <MoveMessageErrorPolicy>().MaxFailedAttemptsCount.Should().Be(42);
        }
        public void MoveToKafkaTopic_EndpointBuilder_MovePolicyCreated()
        {
            var builder = new ErrorPolicyBuilder(_endpointsConfigurationBuilder);

            builder.MoveToKafkaTopic(endpoint => endpoint.ProduceTo("test-move"));
            var policy = builder.Build();

            policy.Should().BeOfType <MoveMessageErrorPolicy>();
            policy.As <MoveMessageErrorPolicy>().Endpoint.Name.Should().Be("test-move");
            policy.As <MoveMessageErrorPolicy>().Endpoint.As <KafkaProducerEndpoint>().Configuration.BootstrapServers
            .Should().Be("PLAINTEXT://tests");
        }
Exemplo n.º 11
0
        // TODO: Test with multiple messages (batch)

        public ErrorPolicyChainTests()
        {
            var services = new ServiceCollection();

            services.AddSilverback().WithConnectionTo <TestBroker>();

            services.AddSingleton <ILoggerFactory, NullLoggerFactory>();
            services.AddSingleton(typeof(ILogger <>), typeof(NullLogger <>));

            _errorPolicyBuilder = new ErrorPolicyBuilder(services.BuildServiceProvider(new ServiceProviderOptions {
                ValidateScopes = true
            }), NullLoggerFactory.Instance);
        }
        public void MoveToMqttTopic_EndpointBuilder_MovePolicyCreated()
        {
            var builder = new ErrorPolicyBuilder(_endpointsConfigurationBuilder);

            builder.MoveToMqttTopic(endpoint => endpoint.ProduceTo("test-move"));
            var policy = builder.Build();

            policy.Should().BeOfType <MoveMessageErrorPolicy>();
            policy.As <MoveMessageErrorPolicy>().Endpoint.Name.Should().Be("test-move");
            policy.As <MoveMessageErrorPolicy>().Endpoint
            .As <MqttProducerEndpoint>().Configuration.ChannelOptions
            .As <MqttClientTcpOptions>().Server.Should().Be("tests-server");
        }
        public void Retry_WithRetriesCountAndDelayAndConfiguration_RetryPolicyCreatedAndConfigurationApplied()
        {
            var builder = new ErrorPolicyBuilder();

            builder.Retry(
                21,
                TimeSpan.FromSeconds(42),
                retryPolicy => retryPolicy.MaxFailedAttempts(retryPolicy.MaxFailedAttemptsCount * 2));
            var policy = builder.Build();

            policy.Should().BeOfType <RetryErrorPolicy>();
            policy.As <RetryErrorPolicy>().MaxFailedAttemptsCount.Should().Be(42);
            policy.As <RetryErrorPolicy>().InitialDelay.Should().Be(TimeSpan.FromSeconds(42));
        }
        public void MoveToKafkaTopic_EndpointBuilderWithConfiguration_SkipPolicyCreatedAndConfigurationApplied()
        {
            var builder = new ErrorPolicyBuilder(_endpointsConfigurationBuilder);

            builder.MoveToKafkaTopic(
                endpoint => endpoint.ProduceTo("test-move"),
                movePolicy => movePolicy.MaxFailedAttempts(42));
            var policy = builder.Build();

            policy.Should().BeOfType <MoveMessageErrorPolicy>();
            policy.As <MoveMessageErrorPolicy>().Endpoint.Name.Should().Be("test-move");
            policy.As <MoveMessageErrorPolicy>().MaxFailedAttemptsCount.Should().Be(42);
            policy.As <MoveMessageErrorPolicy>().Endpoint.As <KafkaProducerEndpoint>().Configuration.BootstrapServers
            .Should().Be("PLAINTEXT://tests");
        }
        public void MoveToMqttTopic_EndpointBuilderWithConfiguration_SkipPolicyCreatedAndConfigurationApplied()
        {
            var builder = new ErrorPolicyBuilder(_endpointsConfigurationBuilder);

            builder.MoveToMqttTopic(
                endpoint => endpoint.ProduceTo("test-move"),
                movePolicy => movePolicy.MaxFailedAttempts(42));
            var policy = builder.Build();

            policy.Should().BeOfType <MoveMessageErrorPolicy>();
            policy.As <MoveMessageErrorPolicy>().Endpoint.Name.Should().Be("test-move");
            policy.As <MoveMessageErrorPolicy>().MaxFailedAttemptsCount.Should().Be(42);
            policy.As <MoveMessageErrorPolicy>().Endpoint
            .As <MqttProducerEndpoint>().Configuration.ChannelOptions
            .As <MqttClientTcpOptions>().Server.Should().Be("tests-server");
        }
Exemplo n.º 16
0
        public MoveMessageErrorPolicyTests()
        {
            var services = new ServiceCollection();

            services.AddSingleton <ILoggerFactory, NullLoggerFactory>();
            services.AddSingleton(typeof(ILogger <>), typeof(NullLogger <>));

            services.AddSilverback().WithConnectionTo <TestBroker>(options => { });

            var serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions {
                ValidateScopes = true
            });

            _errorPolicyBuilder = new ErrorPolicyBuilder(serviceProvider, NullLoggerFactory.Instance);

            _broker = serviceProvider.GetRequiredService <IBroker>();
            _broker.Connect();
        }