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 void SelectBestCandidate_MultipleEndpoints_BestMatchSelected()
{
// Arrange
var defaultEndpoint = new TestEndpoint(
EndpointMetadataCollection.Empty,
"No constraint endpoint");
var postEndpoint = new TestEndpoint(
new EndpointMetadataCollection(new object[] { new HttpMethodEndpointConstraint(new[] { "POST" }) }),
"POST constraint endpoint");
var endpoints = new Endpoint[]
{
defaultEndpoint,
postEndpoint
};
var endpointSelector = CreateSelector(endpoints);
var httpContext = new DefaultHttpContext();
httpContext.Request.Method = "POST";
// Act
var bestCandidateEndpoint = endpointSelector.SelectBestCandidate(httpContext, endpoints);
// Assert
Assert.NotNull(postEndpoint);
}
public void SelectBestCandidate_ConstraintsInOrder()
{
// Arrange
var best = new TestEndpoint(new EndpointMetadataCollection(new[]
{
new BooleanConstraint()
{
Pass = true, Order = 0,
},
}),
"best");
var worst = new TestEndpoint(new EndpointMetadataCollection(new[]
{
new BooleanConstraint()
{
Pass = true, Order = 1,
},
}),
"worst");
var actions = new Endpoint[] { best, worst };
var selector = CreateSelector(actions);
var context = CreateHttpContext("POST");
// Act
var action = selector.SelectBestCandidate(context, actions);
// Assert
Assert.Same(action, best);
}
public async Task SmokeTest()
{
var message1 = new Message(TelemetryMessageSource.Instance, new byte[] { 1, 2, 3 }, new Dictionary <string, string> {
{ "key1", "value1" }, { "key2", "value2" }
});
var endpoint1 = new TestEndpoint("id1");
var endpoint2 = new TestEndpoint("id2");
var allEndpoints = new HashSet <Endpoint> {
endpoint1, endpoint2
};
var route = new Route("id", "true", "hub", TelemetryMessageSource.Instance, new HashSet <Endpoint> {
endpoint1, endpoint2
});
var routes = new HashSet <Route> {
route
};
using (Router router = await Router.CreateAsync("router1", "SmokeTest", new RouterConfig(allEndpoints, routes, Fallback), new SyncEndpointExecutorFactory(TestConstants.DefaultConfig)))
{
await router.RouteAsync(message1);
await router.CloseAsync(CancellationToken.None);
await Assert.ThrowsAsync <InvalidOperationException>(() => router.RouteAsync(message1));
await Assert.ThrowsAsync <InvalidOperationException>(() => router.RouteAsync(new[] { message1 }));
}
var expected = new List <IMessage> {
message1
};
Assert.Equal(expected, endpoint1.Processed);
Assert.Equal(expected, endpoint2.Processed);
}
public void TestReplaceRoutes()
{
var endpoint1 = new TestEndpoint("id1");
var endpoint2 = new TestEndpoint("id2");
var allEndpoints = new HashSet <Endpoint> {
endpoint1, endpoint2
};
var route1 = new Route("id1", "false", "hub", TelemetryMessageSource.Instance, endpoint1, 0, 0);
var route2 = new Route("id2", "true", "hub", TelemetryMessageSource.Instance, endpoint2, 0, 0);
var route3 = new Route("id3", "true", "hub", TelemetryMessageSource.Instance, endpoint1, 0, 0);
var routes = new HashSet <Route> {
route2, route1
};
var evaluator = new Evaluator(new RouterConfig(allEndpoints, routes));
ISet <RouteResult> results = evaluator.Evaluate(Message1);
Assert.Equal(1, results.Count);
Assert.True(routes.SetEquals(evaluator.Routes));
// Add route 3 and remove route 1
var newRoutes = new HashSet <Route> {
route2, route3
};
evaluator.ReplaceRoutes(newRoutes);
results = evaluator.Evaluate(Message1);
Assert.Equal(2, results.Count);
Assert.True(evaluator.Routes.SetEquals(newRoutes));
}
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 void Test_Update_Fail()
{
const string expectedUri = @"https://test.com/update";
var status = new StatusResponse();
status.Error = "FooError";
status.Errors.Add(new ErrorMessage {
error_message = "BarError"
});
var response = new ApiResponse <StatusResponse>(HttpStatusCode.NotFound, "Not Found");
response.Data = status;
var gatewayMock = new Mock <ISoundCloudApiGateway>(MockBehavior.Strict);
gatewayMock.Setup(x => x.InvokeUpdateRequest <StatusResponse>(It.Is <Uri>(y => y.ToString() == expectedUri))).Returns(response);
var endpoint = new TestEndpoint(gatewayMock.Object);
var result = endpoint.Update(expectedUri);
Assert.That(result, Is.InstanceOf <ErrorWebResult <object> >());
Assert.That(result.IsSuccess, Is.False);
Assert.That(result.ErrorMessage, Is.EqualTo("FooError\r\nBarError"));
}
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_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_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_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_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_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 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 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_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 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 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 SmokeTest()
{
var endpoint1 = new TestEndpoint("id1");
var endpoint2 = new TestEndpoint("id1");
var endpoints = new HashSet <Endpoint> {
endpoint1, endpoint2
};
var message = new Message(TelemetryMessageSource.Instance, new byte[0], new Dictionary <string, string>());
Assert.Equal(new List <IMessage>(), endpoint1.Processed);
Assert.Equal(new List <IMessage>(), endpoint2.Processed);
using (Dispatcher dispatcher = await Dispatcher.CreateAsync("dispatcher", "hub", endpoints, SyncExecutorFactory))
{
await dispatcher.DispatchAsync(message, new HashSet <RouteResult> {
new RouteResult(endpoint1, 0, 3600)
});
await dispatcher.CloseAsync(CancellationToken.None);
await Assert.ThrowsAsync <InvalidOperationException>(() => dispatcher.DispatchAsync(message, new HashSet <RouteResult> {
new RouteResult(endpoint1, 0, 3600)
}));
// Ensure a second close doesn't throw
await dispatcher.CloseAsync(CancellationToken.None);
}
var expected = new List <IMessage> {
message
};
Assert.Equal(expected, endpoint1.Processed);
Assert.Equal(new List <IMessage>(), endpoint2.Processed);
}
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 void Test_Create_Params_Fail()
{
const string expectedUri = @"https://test.com/create";
var testEntity = new TestEntity();
var response = new ApiResponse <TestEntity>(HttpStatusCode.NotFound, "Not Found");
response.Data = testEntity;
var parameters = new Dictionary <string, object>();
parameters.Add("foo", "bar");
var gatewayMock = new Mock <ISoundCloudApiGateway>(MockBehavior.Strict);
gatewayMock.Setup(x => x.InvokeCreateRequest <TestEntity>(It.Is <Uri>(y => y.ToString() == expectedUri), parameters)).Returns(response);
var endpoint = new TestEndpoint(gatewayMock.Object);
var result = endpoint.Create <TestEntity>(expectedUri, parameters);
Assert.That(result, Is.InstanceOf <ErrorWebResult <TestEntity> >());
Assert.That(result.IsSuccess, Is.False);
Assert.That(result.Data, Is.Null);
Assert.That(result.ErrorMessage, Is.EqualTo("Not Found"));
}
public void GetProducer_SameEndpoint_SameInstanceIsReturned()
{
var producer = _broker.GetProducer(TestEndpoint.GetDefault());
var producer2 = _broker.GetProducer(TestEndpoint.GetDefault());
producer2.Should().BeSameAs(producer);
}
public async Task TestFallback()
{
var message1 = new Message(TelemetryMessageSource.Instance, new byte[] { 1, 2, 3 }, new Dictionary <string, string> {
{ "key1", "value1" }, { "key2", "value2" }
});
var endpoint1 = new TestEndpoint("id1");
var endpoint2 = new TestEndpoint("id2");
var allEndpoints = new HashSet <Endpoint> {
endpoint1, endpoint2
};
var route = new Route("id", "false", "hub", TelemetryMessageSource.Instance, new HashSet <Endpoint> {
endpoint1
});
var fallback = new Route("$fallback", "true", "hub", TelemetryMessageSource.Instance, new HashSet <Endpoint> {
endpoint2
});
var routes = new HashSet <Route> {
route
};
using (Router router = await Router.CreateAsync("router1", "hub", new RouterConfig(allEndpoints, routes, Option.Some(fallback)), SyncExecutorFactory))
{
await router.RouteAsync(message1);
await router.CloseAsync(CancellationToken.None);
}
var expected = new List <IMessage> {
message1
};
Assert.Equal(new List <IMessage>(), endpoint1.Processed);
Assert.Equal(expected, endpoint2.Processed);
}
public void GetConsumer_DifferentEndpoint_DifferentInstanceIsReturned()
{
var consumer = _broker.GetConsumer(TestEndpoint.GetDefault());
var consumer2 = _broker.GetConsumer(new TestEndpoint("test2"));
consumer2.Should().NotBeSameAs(consumer);
}
public void SelectBestCandidate_ConstraintsRejectAll()
{
// Arrange
var action1 = new TestEndpoint(
new EndpointMetadataCollection(new[] { new BooleanConstraint()
{
Pass = false,
} }),
"action1");
var action2 = new TestEndpoint(
new EndpointMetadataCollection(new[] { new BooleanConstraint()
{
Pass = false,
} }),
"action2");
var actions = new Endpoint[] { action1, action2 };
var selector = CreateSelector(actions);
var context = CreateHttpContext("POST");
// Act
var action = selector.SelectBestCandidate(context, actions);
// Assert
Assert.Null(action);
}
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 void SelectBestCandidate_CustomProvider()
{
// Arrange
var actionWithConstraints = new TestEndpoint(new EndpointMetadataCollection(new[]
{
new BooleanConstraintMarker()
{
Pass = true
},
}),
"actionWithConstraints");
var actionWithoutConstraints = new TestEndpoint(
EndpointMetadataCollection.Empty,
"actionWithoutConstraints");
var actions = new Endpoint[] { actionWithConstraints, actionWithoutConstraints, };
var selector = CreateSelector(actions);
var context = CreateHttpContext("POST");
// Act
var action = selector.SelectBestCandidate(context, actions);
// Assert
Assert.Same(action, actionWithConstraints);
}
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 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 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);
}
