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 void HandleError_InboundMessage_SourceEndpointHeaderIsSet()
{
var policy = _errorPolicyBuilder.Move(TestEndpoint.GetDefault());
var message = new InboundMessage(
Encoding.UTF8.GetBytes("hey oh!"),
null,
null, new TestEndpoint("source-endpoint"), true)
{
Content = "hey oh!",
Headers =
{
{ "key1", "value1" },
{ "key2", "value2" }
}
};
policy.HandleError(new[] { message }, new Exception("test"));
var producer = (TestProducer)_broker.GetProducer(TestEndpoint.GetDefault());
producer.ProducedMessages.Last()
.Headers
.Should().ContainEquivalentOf(new MessageHeader(
MessageHeader.SourceEndpointKey,
"source-endpoint"));
}
public async Task Bind_WithRetryErrorPolicy_RetriedAndReceivedInBatch()
{
_testSubscriber.MustFailCount = 3;
_connector.Bind(TestEndpoint.GetDefault(),
_errorPolicyBuilder.Retry().MaxFailedAttempts(3),
new InboundConnectorSettings
{
Batch = new BatchSettings
{
Size = 2
}
});
_broker.Connect();
var consumer = _broker.Consumers.First();
await consumer.TestPush(new TestEventOne { Content = "Test", Id = Guid.NewGuid() });
await consumer.TestPush(new TestEventOne { Content = "Test", Id = Guid.NewGuid() });
_testSubscriber.FailCount.Should().Be(3);
_testSubscriber.ReceivedMessages.OfType <BatchAbortedEvent>().Count().Should().Be(3);
_testSubscriber.ReceivedMessages.OfType <BatchCompleteEvent>().Count().Should().Be(4);
_testSubscriber.ReceivedMessages.OfType <BatchProcessedEvent>().Count().Should().Be(1);
_testSubscriber.ReceivedMessages.OfType <TestEventOne>().Count().Should().Be(5);
}
public async Task OnMessageReceived_SingleMessage_Queued()
{
var outboundMessage = new OutboundMessage <TestEventOne>(
new TestEventOne {
Content = "Test"
},
new[]
{
new MessageHeader("header1", "value1"),
new MessageHeader("header2", "value2")
},
TestEndpoint.GetDefault());
outboundMessage.RawContent = new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers);
await _connector.RelayMessage(outboundMessage);
await _queue.Commit();
(await _queue.GetLength()).Should().Be(1);
var queued = (await _queue.Dequeue(1)).First();
queued.Endpoint.Should().Be(outboundMessage.Endpoint);
queued.Headers.Count().Should().Be(3);
queued.Content.Should().BeEquivalentTo(new JsonMessageSerializer().Serialize(outboundMessage.Content, outboundMessage.Headers));
}
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_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 void GetProducer_SameEndpoint_SameInstanceIsReturned()
{
var producer = _broker.GetProducer(TestEndpoint.GetDefault());
var producer2 = _broker.GetProducer(TestEndpoint.GetDefault());
producer2.Should().BeSameAs(producer);
}
public OutboundQueueWorkerTests()
{
_queue = new InMemoryOutboundQueue();
var services = new ServiceCollection();
services
.AddSingleton <ILoggerFactory, NullLoggerFactory>()
.AddSingleton(typeof(ILogger <>), typeof(NullLogger <>))
.AddSingleton <IOutboundQueueConsumer, InMemoryOutboundQueue>()
.AddSilverback().WithConnectionTo <TestBroker>(options => options.AddDeferredOutboundConnector(_ => new InMemoryOutboundQueue()));
var serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions {
ValidateScopes = true
});
serviceProvider.GetRequiredService <IOutboundRoutingConfiguration>()
.Add <IIntegrationMessage>(TestEndpoint.GetDefault());
_broker = (TestBroker)serviceProvider.GetRequiredService <IBroker>();
_broker.Connect();
_worker = new OutboundQueueWorker(serviceProvider, _broker, new NullLogger <OutboundQueueWorker>(), new MessageLogger(), true, 100); // TODO: Test order not enforced
InMemoryOutboundQueue.Clear();
_sampleOutboundMessage = new OutboundMessage <TestEventOne>(
new TestEventOne {
Content = "Test"
}, null, TestEndpoint.GetDefault());
_sampleOutboundMessage.RawContent =
new JsonMessageSerializer().Serialize(_sampleOutboundMessage.Content, _sampleOutboundMessage.Headers);
}
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 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_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 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_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 void GetConsumer_DifferentEndpoint_DifferentInstanceIsReturned()
{
var consumer = _broker.GetConsumer(TestEndpoint.GetDefault());
var consumer2 = _broker.GetConsumer(new TestEndpoint("test2"));
consumer2.Should().NotBeSameAs(consumer);
}
public async Task Bind_PushMessagesInBatch_Acknowledged()
{
_connector.Bind(TestEndpoint.GetDefault(), settings: new InboundConnectorSettings
{
Batch = new BatchSettings
{
Size = 5
}
});
_broker.Connect();
var consumer = _broker.Consumers.First();
await consumer.TestPush(new TestEventOne { Id = Guid.NewGuid() });
await consumer.TestPush(new TestEventTwo { Id = Guid.NewGuid() });
await consumer.TestPush(new TestEventOne { Id = Guid.NewGuid() });
await consumer.TestPush(new TestEventTwo { Id = Guid.NewGuid() });
consumer.AcknowledgeCount.Should().Be(0);
await consumer.TestPush(new TestEventTwo { Id = Guid.NewGuid() });
consumer.AcknowledgeCount.Should().Be(5);
}
public async Task Handle_WithTraceIdHeader_NewActivityStartedAndParentIdIsSet()
{
var rawMessage = new RawBrokerMessage(
"123",
new MessageHeaderCollection
{
{ DiagnosticsConstants.TraceIdHeaderKey, "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01" }
},
TestEndpoint.GetDefault());
var entered = false;
await new ActivityConsumerBehavior().Handle(rawMessage, _ =>
{
Activity.Current.Should().NotBeNull();
Activity.Current.ParentId.Should().Be("00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01");
Activity.Current.Id.Should().StartWith("00-0af7651916cd43dd8448eb211c80319c");
entered = true;
return(Task.CompletedTask);
});
entered.Should().BeTrue();
}
public async Task Bind_PushMessageChunksWithDuplicates_FullMessagesReceived()
{
_connector.Bind(TestEndpoint.GetDefault());
_broker.Connect();
var buffer = Convert.FromBase64String(
"eyJDb250ZW50IjoiQSBmdWxsIG1lc3NhZ2UhIiwiSWQiOiI0Mjc1ODMwMi1kOGU5LTQzZjktYjQ3ZS1kN2FjNDFmMmJiMDMifQ==");
var consumer = _broker.Consumers.First();
await consumer.TestPush(buffer.Take(40).ToArray(), new[]
{
new MessageHeader(MessageHeader.MessageIdKey, "123"),
new MessageHeader(MessageHeader.ChunkIdKey, "1"),
new MessageHeader(MessageHeader.ChunksCountKey, "4"),
new MessageHeader(MessageHeader.MessageTypeKey, typeof(TestEventOne).AssemblyQualifiedName)
});
await consumer.TestPush(buffer.Skip(120).ToArray(), new[]
{
new MessageHeader(MessageHeader.MessageIdKey, "123"),
new MessageHeader(MessageHeader.ChunkIdKey, "4"),
new MessageHeader(MessageHeader.ChunksCountKey, "4"),
new MessageHeader(MessageHeader.MessageTypeKey, typeof(TestEventOne).AssemblyQualifiedName)
});
await consumer.TestPush(buffer.Skip(80).Take(40).ToArray(), new[]
{
new MessageHeader(MessageHeader.MessageIdKey, "123"),
new MessageHeader(MessageHeader.ChunkIdKey, "3"),
new MessageHeader(MessageHeader.ChunksCountKey, "4"),
new MessageHeader(MessageHeader.MessageTypeKey, typeof(TestEventOne).AssemblyQualifiedName)
});
await consumer.TestPush(buffer.Skip(120).ToArray(), new[]
{
new MessageHeader(MessageHeader.MessageIdKey, "123"),
new MessageHeader(MessageHeader.ChunkIdKey, "4"),
new MessageHeader(MessageHeader.ChunksCountKey, "4"),
new MessageHeader(MessageHeader.MessageTypeKey, typeof(TestEventOne).AssemblyQualifiedName)
});
await consumer.TestPush(buffer.Skip(80).Take(40).ToArray(), new[]
{
new MessageHeader(MessageHeader.MessageIdKey, "123"),
new MessageHeader(MessageHeader.ChunkIdKey, "3"),
new MessageHeader(MessageHeader.ChunksCountKey, "4"),
new MessageHeader(MessageHeader.MessageTypeKey, typeof(TestEventOne).AssemblyQualifiedName)
});
await consumer.TestPush(buffer.Skip(40).Take(40).ToArray(), new[]
{
new MessageHeader(MessageHeader.MessageIdKey, "123"),
new MessageHeader(MessageHeader.ChunkIdKey, "2"),
new MessageHeader(MessageHeader.ChunksCountKey, "4"),
new MessageHeader(MessageHeader.MessageTypeKey, typeof(TestEventOne).AssemblyQualifiedName)
});
_testSubscriber.ReceivedMessages.Count.Should().Be(1);
_testSubscriber.ReceivedMessages.First().As <TestEventOne>().Content.Should().Be("A full message!");
}
public async Task Bind_PushMessages_HeadersReceivedWithInboundMessages()
{
_connector.Bind(TestEndpoint.GetDefault());
_broker.Connect();
var consumer = _broker.Consumers.First();
await consumer.TestPush(new TestEventOne { Id = Guid.NewGuid() }, new[] { new MessageHeader {
Key = "key", Value = "value1"
} });
await consumer.TestPush(new TestEventOne { Id = Guid.NewGuid() }, new[] { new MessageHeader {
Key = "key", Value = "value2"
} });
var inboundMessages = _inboundSubscriber.ReceivedMessages.OfType <IInboundMessage>();
var firstMessage = inboundMessages.First();
firstMessage.Headers.Count.Should().Be(2);
firstMessage.Headers.Select(h => h.Key).Should().BeEquivalentTo("key", "x-message-type");
firstMessage.Headers.GetValue("key").Should().Be("value1");
var secondMessage = inboundMessages.Skip(1).First();
secondMessage.Headers.Count.Should().Be(2);
secondMessage.Headers.Select(h => h.Key).Should().BeEquivalentTo("key", "x-message-type");
secondMessage.Headers.GetValue("key").Should().Be("value2");
}
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_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 Handle_NoStartedActivity_ActivityStartedAndTraceIdHeaderIsSet()
{
var rawMessage = new RawBrokerMessage("123", null, TestEndpoint.GetDefault());
new ActivityProducerBehavior().Handle(rawMessage, _ => Task.CompletedTask);
rawMessage.Headers.Should().Contain(
h => h.Key == DiagnosticsConstants.TraceIdHeaderKey && !string.IsNullOrEmpty(h.Value));
}
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 async Task ProduceAsync_IntegrationMessage_IdIsSet()
{
var producer = _broker.GetProducer(TestEndpoint.GetDefault());
var message = new TestEventOne();
await producer.ProduceAsync(message);
message.Id.Should().NotBeEmpty();
}
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 AddTest()
{
await _log.Add(new TestEventOne(), TestEndpoint.GetDefault());
await _log.Add(new TestEventOne(), TestEndpoint.GetDefault());
await _log.Add(new TestEventOne(), TestEndpoint.GetDefault());
(await _log.GetLength()).Should().Be(0);
}
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 JoinIfComplete_AllChunks_Joined()
{
var headers = new MessageHeaderCollection();
var originalMessage = new BinaryMessage
{
MessageId = Guid.NewGuid(),
Content = GetByteArray(500)
};
var originalSerializedMessage = _serializer.Serialize(originalMessage, headers);
var chunks = new InboundMessage[3];
chunks[0] = new InboundMessage(
originalSerializedMessage.AsMemory().Slice(0, 300).ToArray(),
new[]
{
new MessageHeader(MessageHeader.MessageIdKey, originalMessage.MessageId.ToString()),
new MessageHeader(MessageHeader.ChunkIdKey, "0"),
new MessageHeader(MessageHeader.ChunksCountKey, "3"),
},
null, TestEndpoint.GetDefault(), true);
chunks[1] = new InboundMessage(
originalSerializedMessage.AsMemory().Slice(300, 300).ToArray(),
new[]
{
new MessageHeader(MessageHeader.MessageIdKey, originalMessage.MessageId.ToString()),
new MessageHeader(MessageHeader.ChunkIdKey, "1"),
new MessageHeader(MessageHeader.ChunksCountKey, "3"),
},
null, TestEndpoint.GetDefault(), true);
chunks[2] = new InboundMessage(
originalSerializedMessage.AsMemory().Slice(600).ToArray(),
new[]
{
new MessageHeader(MessageHeader.MessageIdKey, originalMessage.MessageId.ToString()),
new MessageHeader(MessageHeader.ChunkIdKey, "2"),
new MessageHeader(MessageHeader.ChunksCountKey, "3"),
},
null, TestEndpoint.GetDefault(), true);
var result = await new ChunkConsumer(_store).JoinIfComplete(chunks[0]);
result.Should().BeNull();
result = await new ChunkConsumer(_store).JoinIfComplete(chunks[1]);
result.Should().BeNull();
result = await new ChunkConsumer(_store).JoinIfComplete(chunks[2]);
result.Should().NotBeNull();
var deserializedResult = (BinaryMessage)_serializer.Deserialize(result, headers);
deserializedResult.Content.Should().BeEquivalentTo(originalMessage.Content);
}
public async Task Bind_PushMessages_MessagesReceived()
{
_connector.Bind(TestEndpoint.GetDefault());
_broker.Connect();
var consumer = _broker.Consumers.First();
await consumer.TestPush(new TestEventOne { Id = Guid.NewGuid() }, offset : new TestOffset("a", "1"));
await consumer.TestPush(new TestEventTwo { Id = Guid.NewGuid() }, offset : new TestOffset("a", "2"));
_testSubscriber.ReceivedMessages.Count.Should().Be(2);
}
public void SkipTest(int failedAttempts, ErrorAction expectedAction)
{
var action = _policy.HandleError(new[]
{
new InboundMessage(
new byte[1],
new[] { new MessageHeader(MessageHeader.FailedAttemptsKey, failedAttempts.ToString()) },
null, TestEndpoint.GetDefault(), true)
}, new Exception("test"));
action.Should().Be(expectedAction);
}
public async Task Bind_WithRetryErrorPolicy_RetriedAndReceived()
{
_testSubscriber.MustFailCount = 3;
_connector.Bind(TestEndpoint.GetDefault(), _errorPolicyBuilder.Retry().MaxFailedAttempts(3));
_broker.Connect();
var consumer = _broker.Consumers.First();
await consumer.TestPush(new TestEventOne { Content = "Test", Id = Guid.NewGuid() });
_testSubscriber.FailCount.Should().Be(3);
_testSubscriber.ReceivedMessages.Count.Should().Be(4);
}