public async Task Bind_PushMessagesInBatch_EachIsConsumedOnce() { var e = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var o1 = new TestOffset("a", "1"); var o2 = new TestOffset("b", "1"); var o3 = new TestOffset("a", "2"); _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 } }); _broker.Connect(); var consumer = _broker.Consumers.First(); await consumer.TestPush(e, offset : o1); await consumer.TestPush(e, offset : o2); await consumer.TestPush(e, offset : o3); await consumer.TestPush(e, offset : o2); await consumer.TestPush(e, offset : o1); await consumer.TestPush(e, offset : o3); _testSubscriber.ReceivedMessages.OfType <TestEventOne>().Should().HaveCount(3); }
public async Task JsonSerializer_WithHardcodedMessageType_MessageTypeHeaderIgnored() { var message = new TestEventOne { Content = "Hello E2E!" }; byte[] rawMessage = (await Endpoint.DefaultSerializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty)).ReadAll() ?? throw new InvalidOperationException("Serializer returned null"); Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedMqtt()) .AddMqttEndpoints( endpoints => endpoints .Configure( config => config .WithClientId("e2e-test") .ConnectViaTcp("e2e-mqtt-broker") .UseProtocolVersion(MqttProtocolVersion.V500)) .AddOutbound <IIntegrationEvent>( endpoint => endpoint .ProduceTo(DefaultTopicName) .SerializeAsJson( serializer => serializer.UseFixedType <TestEventOne>())) .AddInbound( endpoint => endpoint .ConsumeFrom(DefaultTopicName) .DeserializeJson( serializer => serializer.UseFixedType <TestEventOne>()))) .AddIntegrationSpy()) .Run(); var producer = Helper.Broker.GetProducer( new MqttProducerEndpoint(DefaultTopicName) { Configuration = ((MqttClientConfigBuilder) new MqttClientConfigBuilder() .WithClientId("e2e-test-helper") .ConnectViaTcp("e2e-mqtt-broker") .UseProtocolVersion(MqttProtocolVersion.V500)) .Build() }); await producer.RawProduceAsync( rawMessage, new MessageHeaderCollection { { DefaultMessageHeaders.MessageType, "Silverback.Bad.TestEventOne, Silverback.Bad" } }); await Helper.WaitUntilAllMessagesAreConsumedAsync(); Helper.Spy.InboundEnvelopes.Should().HaveCount(1); Helper.Spy.InboundEnvelopes[0].Message.Should().BeOfType <TestEventOne>(); }
public async Task Bind_PushMessagesInBatch_WrittenToLog() { var e1 = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var e2 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 } }); _broker.Connect(); var consumer = _broker.Consumers.First(); await consumer.TestPush(e1); await consumer.TestPush(e2); await consumer.TestPush(e1); await consumer.TestPush(e2); await consumer.TestPush(e1); (await _serviceProvider.GetRequiredService <IInboundLog>().GetLength()).Should().Be(2); }
public async Task Bind_PushMessagesInBatch_OnlyCommittedBatchWrittenToLog() { var e1 = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var e2 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; var e3 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; var e4 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 } }); _broker.Connect(); _testSubscriber.FailCondition = m => m is TestEventTwo m2 && m2.Id == e4.Id; var consumer = _broker.Consumers.First(); try { await consumer.TestPush(e1); } catch { } try { await consumer.TestPush(e2); } catch { } try { await consumer.TestPush(e3); } catch { } try { await consumer.TestPush(e4); } catch { } (await _serviceProvider.GetRequiredService <IInboundLog>().GetLength()).Should().Be(2); }
public async Task Bind_PushMessagesInBatch_EachIsConsumedOnce() { var e1 = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var e2 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 } }); _broker.Connect(); var consumer = _broker.Consumers.First(); await consumer.TestPush(e1); await consumer.TestPush(e2); await consumer.TestPush(e1); await consumer.TestPush(e2); await consumer.TestPush(e1); _testSubscriber.ReceivedMessages.Count.Should().Be(6); }
public async Task Bind_PushMessagesInBatch_OffsetStored() { var e = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var o1 = new TestOffset("a", "1"); var o2 = new TestOffset("b", "1"); var o3 = new TestOffset("a", "2"); _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 } }); _broker.Connect(); var consumer = _broker.Consumers.First(); await consumer.TestPush(e, offset : o1); await consumer.TestPush(e, offset : o2); await consumer.TestPush(e, offset : o3); await consumer.TestPush(e, offset : o2); await consumer.TestPush(e, offset : o1); _scopedServiceProvider.GetRequiredService <IOffsetStore>().As <InMemoryOffsetStore>().Count.Should().Be(2); }
public void Equals_SameObjects_TrueIsReturned() { var event1 = new TestEventOne { Message = "one" }; var event2 = new TestEventOne { Message = "two" }; var event3 = new TestEventOne { Message = "three" }; var collection1 = new[] { event1, event2, event3 }; var collection2 = new[] { event1, event2, event3 }; var result = new CollectionEqualityComparer <TestEventOne, string>(obj => obj.Message).Equals( collection1, collection2); result.Should().BeTrue(); }
public async Task PartitionEofCallback_PartitionEofEnabled_HandlerInvoked() { var message = new TestEventOne { Content = "Hello E2E!" }; Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .AddSingletonBrokerCallbackHandler <KafkaPartitionEofCallback>() .WithConnectionToMessageBroker( options => options .AddMockedKafka( mockedKafkaOptions => mockedKafkaOptions.WithDefaultPartitionsCount(5))) .AddKafkaEndpoints( endpoints => endpoints .Configure( config => { config.BootstrapServers = "PLAINTEXT://tests"; }) .AddOutbound <IIntegrationEvent>( endpoint => endpoint.ProduceTo(DefaultTopicName)) .AddInbound( endpoint => endpoint .ConsumeFrom(DefaultTopicName) .Configure( config => { config.GroupId = "consumer1"; config.EnablePartitionEof = true; }))) .AddIntegrationSpyAndSubscriber()) .Run(); var callbackHandlerKafkaEndOfPartitionReached = (KafkaPartitionEofCallback)Host .ScopedServiceProvider .GetServices <IBrokerCallback>() .First(service => service is KafkaPartitionEofCallback); await AsyncTestingUtil.WaitAsync( () => callbackHandlerKafkaEndOfPartitionReached.AllPartitionsEofCallbackCount == 5); var kafkaTestingHelper = Host.ServiceProvider.GetRequiredService <IKafkaTestingHelper>(); var publisher = Host.ScopedServiceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message); await kafkaTestingHelper.WaitUntilAllMessagesAreConsumedAsync(); await AsyncTestingUtil.WaitAsync( () => callbackHandlerKafkaEndOfPartitionReached.AllPartitionsEofCallbackCount == 6); // There are 5 partitions and one message will be published, so in fact 6 times the end of the partition should be reached callbackHandlerKafkaEndOfPartitionReached.AllPartitionsEofCallbackCount.Should().Be(6); kafkaTestingHelper.Spy.OutboundEnvelopes.Should().HaveCount(1); }
public async Task Bind_PushMessages_WrittenToLog() { var e1 = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var e2 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; _connector.Bind(TestEndpoint.GetDefault()); _broker.Connect(); var consumer = _broker.Consumers.First(); await consumer.TestPush(e1); await consumer.TestPush(e2); await consumer.TestPush(e1); await consumer.TestPush(e2); await consumer.TestPush(e1); (await _serviceProvider.GetRequiredService <IInboundLog>().GetLength()).Should().Be(2); }
public async Task Bind_PushMessages_EachIsConsumedOnce() { var e1 = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var e2 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; var o1 = new TestOffset("a", "1"); var o2 = new TestOffset("a", "2"); _connector.Bind(TestEndpoint.GetDefault()); _broker.Connect(); var consumer = _broker.Consumers.First(); await consumer.TestPush(e1, offset : o1); await consumer.TestPush(e2, offset : o2); await consumer.TestPush(e1, offset : o1); await consumer.TestPush(e2, offset : o2); await consumer.TestPush(e1, offset : o1); _testSubscriber.ReceivedMessages.Count.Should().Be(2); }
public async Task Bind_PushMessages_OffsetStored() { var e = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var o1 = new TestOffset("a", "1"); var o2 = new TestOffset("b", "1"); var o3 = new TestOffset("a", "2"); _connector.Bind(TestEndpoint.GetDefault()); _broker.Connect(); var consumer = _broker.Consumers.First(); await consumer.TestPush(e, offset : o1); await consumer.TestPush(e, offset : o2); await consumer.TestPush(e, offset : o3); await consumer.TestPush(e, offset : o2); await consumer.TestPush(e, offset : o1); _scopedServiceProvider.GetRequiredService <IOffsetStore>().As <InMemoryOffsetStore>().Count.Should().Be(2); }
public async Task Bind_PushMessagesInBatch_OnlyOffsetOfCommittedBatchStored() { var e = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var fail = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var o1 = new TestOffset("a", "1"); var o2 = new TestOffset("a", "2"); var o3 = new TestOffset("a", "3"); var o4 = new TestOffset("a", "4"); _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 } }); _broker.Connect(); _testSubscriber.FailCondition = m => m is TestEventOne m2 && m2.Id == fail.Id; var consumer = _broker.Consumers.First(); try { await consumer.TestPush(e, offset : o1); } catch { } try { await consumer.TestPush(e, offset : o2); } catch { } try { await consumer.TestPush(e, offset : o3); } catch { } try { await consumer.TestPush(fail, offset : o4); } catch { } (await _scopedServiceProvider.GetRequiredService <IOffsetStore>().GetLatestValue("a")).Value.Should().Be("2"); }
public void HandleError_InboundMessage_MessagePreserved() { var policy = _errorPolicyBuilder.Move(TestEndpoint.GetDefault()); var content = new TestEventOne { Content = "hey oh!" }; var headers = new MessageHeaderCollection(); var rawContent = TestEndpoint.GetDefault().Serializer.Serialize(content, headers); var message = new InboundMessage(rawContent, headers, null, TestEndpoint.GetDefault(), true) { Content = content, Headers = { { "key1", "value1" }, { "key2", "value2" } } }; policy.HandleError(new[] { message }, new Exception("test")); var producer = (TestProducer)_broker.GetProducer(TestEndpoint.GetDefault()); var producedMessage = producer.ProducedMessages.Last(); var deserializedMessage = producedMessage.Endpoint.Serializer.Deserialize(producedMessage.Message, producedMessage.Headers); deserializedMessage.Should().BeEquivalentTo(message.Content); }
public async Task SerializeUsing_NewtonsoftJsonSerializer_PayloadSerialized() { var message = new TestEventOne { Content = "Hello MQTT!" }; var serializer = new NewtonsoftJsonMessageSerializer <TestEventOne> { Encoding = MessageEncoding.Unicode, Settings = new JsonSerializerSettings { Formatting = Formatting.Indented } }; var messageBytes = (await serializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty)).ReadAll(); var builder = new MqttLastWillMessageBuilder(); builder .ProduceTo("testaments") .SerializeUsing(serializer) .Message(message); var willMessage = builder.Build(); willMessage.Payload.Should().NotBeNullOrEmpty(); willMessage.Payload.Should().BeEquivalentTo(messageBytes); }
public async Task Outbound_DefaultSettings_SerializedAndProduced() { var message = new TestEventOne { Content = "Hello E2E!" }; var rawMessage = (await Endpoint.DefaultSerializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty)).ReadAll(); var serviceProvider = Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedKafka()) .AddEndpoints( endpoints => endpoints .AddOutbound <IIntegrationEvent>(new KafkaProducerEndpoint(DefaultTopicName))) .AddSingletonBrokerBehavior <SpyBrokerBehavior>() .AddSingletonSubscriber <OutboundInboundSubscriber>()) .Run(); var publisher = serviceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message); Subscriber.OutboundEnvelopes.Should().HaveCount(1); SpyBehavior.OutboundEnvelopes.Should().HaveCount(1); SpyBehavior.OutboundEnvelopes[0].RawMessage.ReReadAll().Should().BeEquivalentTo(rawMessage); }
public async Task Outbound_DefaultSettings_SerializedAndProduced() { var message = new TestEventOne { Content = "Hello E2E!" }; var rawMessage = (await Endpoint.DefaultSerializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty)).ReadAll(); Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedKafka()) .AddKafkaEndpoints( endpoints => endpoints .Configure( config => { config.BootstrapServers = "PLAINTEXT://tests"; }) .AddOutbound <IIntegrationEvent>( endpoint => endpoint.ProduceTo(DefaultTopicName))) .AddIntegrationSpyAndSubscriber()) .Run(); var publisher = Host.ScopedServiceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message); Helper.Spy.OutboundEnvelopes.Should().HaveCount(1); Helper.Spy.OutboundEnvelopes[0].RawMessage.ReReadAll().Should().BeEquivalentTo(rawMessage); }
public async Task SerializeAsJson_Action_PayloadSerialized() { var message = new TestEventOne { Content = "Hello MQTT!" }; var serializer = new JsonMessageSerializer <TestEventOne> { Options = new JsonSerializerOptions { WriteIndented = true } }; var messageBytes = (await serializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty)).ReadAll(); var builder = new MqttLastWillMessageBuilder(); builder .ProduceTo("testaments") .SerializeAsJson( serializerBuilder => serializerBuilder .WithOptions( new JsonSerializerOptions { WriteIndented = true })) .Message(message); var willMessage = builder.Build(); willMessage.Payload.Should().NotBeNullOrEmpty(); willMessage.Payload.Should().BeEquivalentTo(messageBytes); }
public async Task DefaultSettings_MessageIdUsedAsKafkaKey() { var message = new TestEventOne { Content = "Hello E2E!" }; Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedKafka()) .AddEndpoints( endpoints => endpoints .AddOutbound <IIntegrationEvent>(new KafkaProducerEndpoint("test-e2e")) .AddInbound(new KafkaConsumerEndpoint("test-e2e"))) .AddSingletonBrokerBehavior <SpyBrokerBehavior>()) .Run(); var publisher = Host.ScopedServiceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message); SpyBehavior.InboundEnvelopes.Should().HaveCount(1); var inboundMessageId = SpyBehavior.InboundEnvelopes[0].Headers[DefaultMessageHeaders.MessageId]; var inboundKafkaKey = SpyBehavior.InboundEnvelopes[0].Headers[KafkaMessageHeaders.KafkaMessageKey]; inboundKafkaKey.Should().Be(inboundMessageId); }
public async Task ChunkingWithBatchConsuming_CorrectlyConsumedInBatchAndAggregated() { var message1 = new TestEventOne { Content = "Hello E2E!" }; var message2 = new TestEventOne { Content = "Hello E2E!" }; var serviceProvider = Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedKafka()) .AddEndpoints( endpoints => endpoints .AddOutbound <IIntegrationEvent>( new KafkaProducerEndpoint(DefaultTopicName) { Chunk = new ChunkSettings { Size = 10 } }) .AddInbound( new KafkaConsumerEndpoint(DefaultTopicName) { Batch = new BatchSettings { Size = 2 } })) .AddSingletonBrokerBehavior <SpyBrokerBehavior>()) .Run(); var publisher = serviceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message1); await KafkaTestingHelper.WaitUntilAllMessagesAreConsumedAsync(); SpyBehavior.OutboundEnvelopes.Should().HaveCount(3); SpyBehavior.InboundEnvelopes.Should().BeEmpty(); await publisher.PublishAsync(message2); await KafkaTestingHelper.WaitUntilAllMessagesAreConsumedAsync(); SpyBehavior.OutboundEnvelopes.Should().HaveCount(6); SpyBehavior.OutboundEnvelopes.ForEach( envelope => { envelope.RawMessage.Should().NotBeNull(); envelope.RawMessage !.Length.Should().BeLessOrEqualTo(10); }); SpyBehavior.InboundEnvelopes.Should().HaveCount(2); }
public async Task MovePolicy_ToOtherTopicAfterRetry_MessageRetriedAndMoved() { var message = new TestEventOne { Content = "Hello E2E!" }; var tryCount = 0; Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedMqtt()) .AddMqttEndpoints( endpoints => endpoints .Configure( config => config .WithClientId("e2e-test") .ConnectViaTcp("e2e-mqtt-broker")) .AddOutbound <IIntegrationEvent>( endpoint => endpoint.ProduceTo(DefaultTopicName)) .AddInbound( endpoint => endpoint .ConsumeFrom(DefaultTopicName) .OnError( policy => policy .Retry(1) .ThenMoveToMqttTopic( moveEndpoint => moveEndpoint.ProduceTo("e2e/other"))))) .AddIntegrationSpy() .AddDelegateSubscriber( (IIntegrationEvent _) => { tryCount++; throw new InvalidOperationException("Retry!"); })) .Run(); var publisher = Host.ScopedServiceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message); await Helper.WaitUntilAllMessagesAreConsumedAsync(); Helper.Spy.OutboundEnvelopes.Should().HaveCount(2); Helper.Spy.InboundEnvelopes.Should().HaveCount(2); tryCount.Should().Be(2); Helper.Spy.OutboundEnvelopes[1].Message.Should() .BeEquivalentTo(Helper.Spy.OutboundEnvelopes[0].Message); Helper.Spy.OutboundEnvelopes[1].Endpoint.Name.Should().Be("e2e/other"); var otherTopicMessages = Helper.GetMessages("e2e/other"); otherTopicMessages.Count.Should().Be(1); otherTopicMessages[0].Payload.Should() .BeEquivalentTo(Helper.Spy.InboundEnvelopes[0].RawMessage.ReReadAll()); }
public async Task EncryptionAndChunking_EncryptedAndChunkedThenAggregatedAndDecrypted() { var message = new TestEventOne { Content = "Hello E2E!" }; var rawMessage = await Endpoint.DefaultSerializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty) ?? throw new InvalidOperationException("Serializer returned null"); var serviceProvider = Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedKafka()) .AddEndpoints( endpoints => endpoints .AddOutbound <IIntegrationEvent>( new KafkaProducerEndpoint(DefaultTopicName) { Chunk = new ChunkSettings { Size = 10 }, Encryption = new SymmetricEncryptionSettings { Key = AesEncryptionKey } }) .AddInbound( new KafkaConsumerEndpoint(DefaultTopicName) { Encryption = new SymmetricEncryptionSettings { Key = AesEncryptionKey } })) .AddSingletonBrokerBehavior <SpyBrokerBehavior>()) .Run(); var publisher = serviceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message); await KafkaTestingHelper.WaitUntilAllMessagesAreConsumedAsync(); SpyBehavior.OutboundEnvelopes.Should().HaveCount(5); SpyBehavior.OutboundEnvelopes[0].RawMessage.Should().NotBeEquivalentTo(rawMessage.Read(10)); SpyBehavior.OutboundEnvelopes.ForEach( envelope => { envelope.RawMessage.Should().NotBeNull(); envelope.RawMessage !.Length.Should().BeLessOrEqualTo(10); }); SpyBehavior.InboundEnvelopes.Should().HaveCount(1); SpyBehavior.InboundEnvelopes[0].Message.Should().BeEquivalentTo(message); }
public void When_an_event_is_applied() { var testEvent = new TestEventOne(); _aggregate.Raise(testEvent); ((IEvented)_aggregate).GetPendingEvents().ShouldHaveSingleItem().Data.ShouldBe(testEvent); }
public async Task RetryPolicy_EncryptedMessage_RetriedMultipleTimes() { var message = new TestEventOne { Content = "Hello E2E!" }; var rawMessageStream = await Endpoint.DefaultSerializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty); var tryCount = 0; Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedMqtt()) .AddMqttEndpoints( endpoints => endpoints .Configure( config => config .WithClientId("e2e-test") .ConnectViaTcp("e2e-mqtt-broker")) .AddOutbound <IIntegrationEvent>( endpoint => endpoint .ProduceTo(DefaultTopicName) .EncryptUsingAes(AesEncryptionKey)) .AddInbound( endpoint => endpoint .ConsumeFrom(DefaultTopicName) .OnError(policy => policy.Retry(10)) .DecryptUsingAes(AesEncryptionKey))) .AddIntegrationSpy() .AddDelegateSubscriber( (IIntegrationEvent _) => { tryCount++; if (tryCount != 3) { throw new InvalidOperationException("Retry!"); } })) .Run(); var publisher = Host.ScopedServiceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message); await Helper.WaitUntilAllMessagesAreConsumedAsync(); Helper.Spy.OutboundEnvelopes.Should().HaveCount(1); Helper.Spy.OutboundEnvelopes[0].RawMessage.ReadAll().Should() .NotBeEquivalentTo(rawMessageStream.ReReadAll()); Helper.Spy.InboundEnvelopes.Should().HaveCount(3); Helper.Spy.InboundEnvelopes.ForEach( envelope => envelope.Message.Should().BeEquivalentTo(message)); }
public async Task Bind_PushMessagesInBatchToMultipleConsumers_OnlyOffsetOfCommittedBatchStored() { var e = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var fail = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var o1 = new TestOffset("a", "1"); var o2 = new TestOffset("a", "2"); var o3 = new TestOffset("a", "3"); var o4 = new TestOffset("a", "4"); _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 }, Consumers = 2 }); _broker.Connect(); _testSubscriber.FailCondition = m => m is TestEventOne m2 && m2.Id == fail.Id; var consumer1 = _broker.Consumers[0]; var consumer2 = _broker.Consumers[1]; var tasks = new[] { Task.Run(async() => { try { await consumer1.TestPush(e, offset: o1); await consumer1.TestPush(e, offset: o2); } catch (Exception) { } }), Task.Run(async() => { try { await consumer2.TestPush(e, offset: o3); await consumer2.TestPush(fail, offset: o4); } catch (Exception) { } }) }; await Task.WhenAll(tasks); (await _scopedServiceProvider.GetRequiredService <IOffsetStore>().GetLatestValue("a")).Value.Should().Be("2"); }
public void Produce_IntegrationMessage_IdIsSet() { var producer = _broker.GetProducer(TestEndpoint.GetDefault()); var message = new TestEventOne(); producer.Produce(message); message.Id.Should().NotBeEmpty(); }
public async Task ProduceAsync_IntegrationMessage_IdIsSet() { var producer = _broker.GetProducer(TestEndpoint.GetDefault()); var message = new TestEventOne(); await producer.ProduceAsync(message); message.Id.Should().NotBeEmpty(); }
public async Task NewtonsoftSerializer_WithHardcodedMessageType_MessageTypeHeaderIgnored() { var message = new TestEventOne { Content = "Hello E2E!" }; byte[] rawMessage = (await Endpoint.DefaultSerializer.SerializeAsync( message, new MessageHeaderCollection(), MessageSerializationContext.Empty)).ReadAll() ?? throw new InvalidOperationException("Serializer returned null"); Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedKafka()) .AddKafkaEndpoints( endpoints => endpoints .Configure(config => { config.BootstrapServers = "PLAINTEXT://e2e"; }) .AddInbound( endpoint => endpoint .ConsumeFrom(DefaultTopicName) .Configure( config => { config.GroupId = "consumer1"; }) .DeserializeJsonUsingNewtonsoft( serializer => serializer.UseFixedType <TestEventOne>()))) .AddIntegrationSpy()) .Run(); var producer = Helper.Broker.GetProducer( new KafkaProducerEndpoint(DefaultTopicName) { Configuration = new KafkaProducerConfig { BootstrapServers = "PLAINTEXT://e2e" } }); await producer.RawProduceAsync( rawMessage, new MessageHeaderCollection { { DefaultMessageHeaders.MessageType, "Silverback.Bad.TestEventOne, Silverback.Bad" } }); await Helper.WaitUntilAllMessagesAreConsumedAsync(); Helper.Spy.InboundEnvelopes.Should().HaveCount(1); Helper.Spy.InboundEnvelopes[0].Message.Should().BeOfType <TestEventOne>(); }
public async Task Encryption_SimpleMessages_EncryptedAndDecrypted() { var message1 = new TestEventOne { Content = "Message 1" }; var message2 = new TestEventOne { Content = "Message 2" }; Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker(options => options.AddMockedMqtt()) .AddMqttEndpoints( endpoints => endpoints .Configure( config => config .WithClientId("e2e-test") .ConnectViaTcp("e2e-mqtt-broker")) .AddOutbound <IIntegrationEvent>( endpoint => endpoint .ProduceTo(DefaultTopicName) .EncryptUsingAes(AesEncryptionKey)) .AddInbound( endpoint => endpoint .ConsumeFrom(DefaultTopicName) .DecryptUsingAes(AesEncryptionKey))) .AddIntegrationSpyAndSubscriber()) .Run(); var publisher = Host.ScopedServiceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message1); await publisher.PublishAsync(message2); await Helper.WaitUntilAllMessagesAreConsumedAsync(); Helper.Spy.OutboundEnvelopes.Should().HaveCount(2); Helper.Spy.OutboundEnvelopes[0].RawMessage.Should().BeOfType <SymmetricEncryptStream>(); Helper.Spy.OutboundEnvelopes[1].RawMessage.Should().BeOfType <SymmetricEncryptStream>(); Helper.Spy.OutboundEnvelopes.ForEach( envelope => envelope.Headers.GetValue(DefaultMessageHeaders.EncryptionKeyId).Should().BeNull()); Helper.Spy.InboundEnvelopes.Should().HaveCount(2); Helper.Spy.InboundEnvelopes[0].Message.Should().BeEquivalentTo(message1); Helper.Spy.InboundEnvelopes[1].Message.Should().BeEquivalentTo(message2); Helper.Spy.InboundEnvelopes.ForEach( envelope => envelope.Headers.GetValue(DefaultMessageHeaders.EncryptionKeyId).Should().BeNull()); }
public async Task Bind_PushMessagesInBatchToMultipleConsumers_OnlyCommittedBatchWrittenToLog() { var e1 = new TestEventOne { Content = "Test", Id = Guid.NewGuid() }; var e2 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; var e3 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; var e4 = new TestEventTwo { Content = "Test", Id = Guid.NewGuid() }; _connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings { Batch = new Silverback.Messaging.Batch.BatchSettings { Size = 2 }, Consumers = 2 }); _broker.Connect(); _testSubscriber.FailCondition = m => m is TestEventTwo m2 && m2.Id == e2.Id; var consumer1 = _broker.Consumers[0]; var consumer2 = _broker.Consumers[1]; var tasks = new[] { Task.Run(async() => { try { await consumer1.TestPush(e1); await consumer1.TestPush(e2); } catch (Exception) { } }), Task.Run(async() => { await consumer2.TestPush(e3); await consumer2.TestPush(e4); }) }; await Task.WhenAll(tasks); (await _serviceProvider.GetRequiredService <IInboundLog>().GetLength()).Should().Be(2); }
public async Task Encryption_SimpleMessages_EncryptedAndDecrypted() { var message1 = new TestEventOne { Content = "Message 1" }; var message2 = new TestEventOne { Content = "Message 2" }; Host.ConfigureServices( services => services .AddLogging() .AddSilverback() .UseModel() .WithConnectionToMessageBroker( options => options.AddMockedKafka( mockedKafkaOptions => mockedKafkaOptions.WithDefaultPartitionsCount(1))) .AddKafkaEndpoints( endpoints => endpoints .Configure(config => { config.BootstrapServers = "PLAINTEXT://e2e"; }) .AddOutbound <IIntegrationEvent>( endpoint => endpoint .ProduceTo(DefaultTopicName) .EncryptUsingAes(AesEncryptionKey)) .AddInbound( endpoint => endpoint .ConsumeFrom(DefaultTopicName) .DecryptUsingAes(AesEncryptionKey) .Configure( config => { config.GroupId = "consumer1"; }))) .AddIntegrationSpyAndSubscriber()) .Run(); var publisher = Host.ScopedServiceProvider.GetRequiredService <IEventPublisher>(); await publisher.PublishAsync(message1); await publisher.PublishAsync(message2); await Helper.WaitUntilAllMessagesAreConsumedAsync(); Helper.Spy.OutboundEnvelopes.Should().HaveCount(2); Helper.Spy.OutboundEnvelopes[0].RawMessage.Should().BeOfType <SymmetricEncryptStream>(); Helper.Spy.OutboundEnvelopes[1].RawMessage.Should().BeOfType <SymmetricEncryptStream>(); Helper.Spy.InboundEnvelopes.Should().HaveCount(2); Helper.Spy.InboundEnvelopes[0].Message.Should().BeEquivalentTo(message1); Helper.Spy.InboundEnvelopes[1].Message.Should().BeEquivalentTo(message2); DefaultTopic.GetCommittedOffsetsCount("consumer1").Should().Be(2); }