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);
}
