public async Task Should_connect_with_credentials()
{
var busControl = Bus.Factory.CreateUsingAmazonSqs(cfg =>
{
BusTestFixture.ConfigureBusDiagnostics(cfg);
cfg.Host(new Uri("amazonsqs://localhost:4566"), h =>
{
h.AccessKey("admin");
h.SecretKey("admin");
h.Config(new AmazonSimpleNotificationServiceConfig {
ServiceURL = "http://localhost:4566"
});
h.Config(new AmazonSQSConfig {
ServiceURL = "http://localhost:4566"
});
});
});
try
{
await busControl.StartAsync();
}
finally
{
await busControl.StopAsync();
}
}
public async Task Should_recover_from_a_crashed_server()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.ReceiveEndpoint("input-queue", e =>
{
});
});
var handle = await busControl.StartAsync();
try
{
Console.WriteLine("Waiting for connection...");
await handle.Ready;
await Task.Delay(30000);
}
finally
{
await handle.StopAsync();
}
}
public async Task Should_startup_and_shut_down_cleanly_with_an_endpoint()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(new Uri("rabbitmq://localhost/"), h =>
{
});
x.ReceiveEndpoint("input_queue", e =>
{
e.Handler <Test>(async context =>
{
});
});
});
var handle = await busControl.StartAsync(TestCancellationToken);
try
{
Console.WriteLine("Waiting for connection...");
await handle.Ready;
await Task.Delay(60000);
}
finally
{
await handle.StopAsync(TestCancellationToken);
}
}
public async Task Should_not_create_bus_endpoint_queue_on_startup()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
var bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h => h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
}));
});
var busHandle = await bus.StartAsync();
try
{
}
finally
{
await busHandle.StopAsync();
}
}
public async Task Should_fault_nicely()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(new Uri("rabbitmq://unknownhost:32787"), h =>
{
h.Username("whocares");
h.Password("Ohcrud");
h.RequestedConnectionTimeout(2000);
});
x.AutoStart = true;
});
Assert.ThrowsAsync <RabbitMqConnectionException>(async() =>
{
BusHandle handle;
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
handle = await busControl.StartAsync(timeout.Token).OrCanceled(TestCancellationToken);
}
await handle.StopAsync(CancellationToken.None);
});
}
public async Task Should_fault_with_operation_cancelled_on_publish()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host("unknown_host");
x.AutoStart = true;
});
using var startTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(20));
var startTask = busControl.StartAsync(startTimeout.Token).OrCanceled(TestCancellationToken);
var publishTimer = Stopwatch.StartNew();
Assert.ThrowsAsync <OperationCanceledException>(async() =>
{
using var publishTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
await busControl.Publish(new PingMessage(), publishTimeout.Token);
});
publishTimer.Stop();
var publishElapsed = publishTimer.Elapsed;
Assert.That(publishElapsed, Is.LessThan(TimeSpan.FromSeconds(19)));
Assert.ThrowsAsync <RabbitMqConnectionException>(async() =>
{
await startTask;
});
}
public async Task Should_fault_when_credentials_are_bad()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(new Uri("rabbitmq://localhost/"), h =>
{
h.Username("guest");
h.Password("guessed");
});
});
Assert.That(async() =>
{
var handle = await busControl.StartAsync();
try
{
Console.WriteLine("Waiting for connection...");
await handle.Ready;
}
finally
{
await handle.StopAsync();
}
}, Throws.TypeOf <RabbitMqConnectionException>());
}
public async Task Should_not_timeout()
{
var harness = new InMemoryTestHarness();
var machine = new TestSagaStateMachine();
StateMachineSagaTestHarness <TestSaga, TestSagaStateMachine> sagaHarness = harness.StateMachineSaga <TestSaga, TestSagaStateMachine>(machine);
harness.TestTimeout = TimeSpan.FromSeconds(15);
harness.OnConfigureBus += x => BusTestFixture.ConfigureBusDiagnostics(x);
await harness.Start();
// Act
try
{
IRequestClient <StartCommand> client = harness.CreateRequestClient <StartCommand>();
Response <StartCommandResponse> response = await client.GetResponse <StartCommandResponse>(
new
{
CorrelationId = InVar.Id,
});
// Assert
// did the actual saga consume the message
Assert.True(await sagaHarness.Consumed.Any <StartCommand>());
}
finally
{
await harness.Stop();
}
}
public async Task Should_support_the_new_syntax()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceBusNamespace = Configuration.ServiceNamespace;
var serviceUri = AzureServiceBusEndpointUriCreator.Create(
serviceBusNamespace,
"MassTransit.Azure.ServiceBus.Core.Tests"
);
TaskCompletionSource <A> completed = TaskUtil.GetTask <A>();
var bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
x.ReceiveEndpoint("input_queue", e =>
{
e.PrefetchCount = 16;
e.Handler <A>(async context => completed.TrySetResult(context.Message));
// Add a message handler and configure the pipeline to retry the handler
// if an exception is thrown
e.Handler <A>(Handle, h =>
{
h.UseRetry(r => r.Interval(5, 100));
});
});
});
var busHandle = await bus.StartAsync(TestCancellationToken);
try
{
}
finally
{
await busHandle.StopAsync();
}
// }))
// {
// var queueAddress = new Uri(hostAddress, "input_queue");
// ISendEndpoint endpoint = bus.GetSendEndpoint(queueAddress);
//
// await endpoint.Send(new A());
// }
}
public async Task Should_succeed_and_connect_when_properly_configured()
{
var received = new TaskCompletionSource <bool>();
var busControl = Bus.Factory.CreateUsingAmazonSqs(cfg =>
{
BusTestFixture.ConfigureBusDiagnostics(cfg);
cfg.Host(new Uri("amazonsqs://localhost:4566"), h =>
{
h.AccessKey("admin");
h.SecretKey("admin");
h.Config(new AmazonSimpleNotificationServiceConfig {
ServiceURL = "http://localhost:4566"
});
h.Config(new AmazonSQSConfig {
ServiceURL = "http://localhost:4566"
});
});
cfg.ReceiveEndpoint("input-queue", x =>
{
x.Handler <PingMessage>(async context =>
{
await context.Publish(new PongMessage(context.Message.CorrelationId));
});
});
cfg.ReceiveEndpoint("input-queue-too", x =>
{
x.Handler <PongMessage>(async context =>
{
received.TrySetResult(true);
await TaskUtil.Completed;
});
});
});
await busControl.StartAsync();
try
{
await busControl.Publish(new PingMessage());
await received.Task.OrTimeout(TimeSpan.FromSeconds(30));
}
finally
{
await busControl.StopAsync();
}
}
public async Task Should_create_receive_endpoint_and_start()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
Uri serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
TaskCompletionSource <PingMessage> handled = new TaskCompletionSource <PingMessage>();
IBusControl bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h =>
{
#if NET461
h.TransportType = TransportType.AmqpWebSockets;
#endif
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
x.ReceiveEndpoint("test-input-queue", e =>
{
e.Handler <PingMessage>(async context =>
{
handled.TrySetResult(context.Message);
});
});
});
BusHandle busHandle = await bus.StartAsync();
try
{
var endpoint = await bus.GetSendEndpoint(new Uri("queue:test-input-queue"));
await endpoint.Send(new PingMessage());
await handled.Task.OrTimeout(TimeSpan.FromSeconds(10000));
}
finally
{
await busHandle.StopAsync(new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
}
}
public async Task Should_create_receive_endpoint_and_start()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
var handled = new TaskCompletionSource <PingMessage>();
var bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
x.ReceiveEndpoint(e =>
{
e.RemoveSubscriptions = true;
e.Handler <PingMessage>(async context =>
{
await Task.Delay(TimeSpan.FromSeconds(1));
handled.TrySetResult(context.Message);
});
});
});
var busHandle = await bus.StartAsync();
try
{
await bus.Publish(new PingMessage());
await handled.Task.OrTimeout(TimeSpan.FromSeconds(10000));
}
finally
{
await busHandle.StopAsync(new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
}
}
public async Task Should_start_without_any_configuration()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
});
var handle = await busControl.StartAsync(new CancellationTokenSource(5000).Token);
try
{
await handle.Ready;
}
finally
{
await handle.StopAsync();
}
}
public async Task Should_startup_and_shut_down_cleanly()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x => BusTestFixture.ConfigureBusDiagnostics(x));
BusHandle handle;
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
{
handle = await busControl.StartAsync(timeout.Token);
}
try
{
await handle.Ready;
}
finally
{
await handle.StopAsync(CancellationToken.None);
}
}
public async Task Should_do_a_bunch_of_requests_and_responses()
{
var bus = Bus.Factory.CreateUsingAmazonSqs(sbc =>
{
BusTestFixture.ConfigureBusDiagnostics(sbc);
sbc.Host(new Uri("amazonsqs://localhost:4566"), h =>
{
h.AccessKey("admin");
h.SecretKey("admin");
h.Config(new AmazonSimpleNotificationServiceConfig {
ServiceURL = "http://localhost:4566"
});
h.Config(new AmazonSQSConfig {
ServiceURL = "http://localhost:4566"
});
});
sbc.ReceiveEndpoint("test", e =>
{
e.Handler <PingMessage>(async context =>
{
await context.RespondAsync(new PongMessage(context.Message.CorrelationId));
});
});
});
await bus.StartAsync();
try
{
for (var i = 0; i < 100; i += 1)
{
Response <PongMessage> result = await bus.Request <PingMessage, PongMessage>(new PingMessage(), timeout : TimeSpan.FromSeconds(60));
}
}
finally
{
await bus.StopAsync();
}
}
public async Task Using_DI_should_not_timeout()
{
var provider = new ServiceCollection()
.AddMassTransitInMemoryTestHarness(cfg =>
{
cfg.AddSagaStateMachine <TestSagaStateMachine, TestSaga>()
.InMemoryRepository();
cfg.AddSagaStateMachineTestHarness <TestSagaStateMachine, TestSaga>();
cfg.AddPublishMessageScheduler();
cfg.AddRequestClient <StartCommand>();
})
.BuildServiceProvider(true);
var harness = provider.GetRequiredService <InMemoryTestHarness>();
harness.TestTimeout = TimeSpan.FromSeconds(15);
harness.OnConfigureBus += x => BusTestFixture.ConfigureBusDiagnostics(x);
await harness.Start();
// Act
try
{
using var scope = provider.CreateScope();
IRequestClient <StartCommand> client = scope.ServiceProvider.GetRequiredService <IRequestClient <StartCommand> >();
Response <StartCommandResponse> response = await client.GetResponse <StartCommandResponse>(
new
{
CorrelationId = InVar.Id,
});
// Assert
// did the actual saga consume the message
var sagaHarness = provider.GetRequiredService <IStateMachineSagaTestHarness <TestSaga, TestSagaStateMachine> >();
Assert.True(await sagaHarness.Consumed.Any <StartCommand>());
}
finally
{
await harness.Stop();
}
}
public async Task Should_startup_and_shut_down_cleanly_with_publish()
{
var busControl = Bus.Factory.CreateUsingRabbitMq(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(new Uri("rabbitmq://localhost/"), h =>
{
});
});
await busControl.StartAsync();
try
{
await busControl.Publish(new TestMessage());
}
finally
{
await busControl.StopAsync();
}
}
public async Task Should_start_and_stop_sync()
{
var queueUri = new Uri("rabbitmq://localhost/test/input_queue2");
var rabbitMqHostSettings = queueUri.GetHostSettings();
var receiveSettings = queueUri.GetReceiveSettings();
var bus = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
BusTestFixture.ConfigureBusDiagnostics(sbc);
sbc.Host(rabbitMqHostSettings);
sbc.ReceiveEndpoint(receiveSettings.QueueName, ep =>
{
});
});
bus.Start();
await bus.Publish(new DummyMessage { ID = 1 }).ConfigureAwait(false);
bus.Stop();
}
public async Task Should_recreate_the_subscription()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
var busControl = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
x.SubscriptionEndpoint("input-subscription", "input-topic", e =>
{
});
});
var handle = await busControl.StartAsync();
try
{
Console.WriteLine("Waiting for connection...");
await handle.Ready;
await Task.Delay(40000);
}
finally
{
await handle.StopAsync();
}
}
public async Task Should_create_queue_with_multiple_subscriptions()
{
Type[] messageTypes =
{
typeof(Message0),
typeof(Message1),
typeof(Message2),
typeof(Message3),
typeof(Message4),
typeof(Message5),
typeof(Message6),
typeof(Message7),
typeof(Message8),
typeof(Message9),
typeof(Message10),
typeof(Message11),
typeof(Message12),
typeof(Message13),
typeof(Message14),
typeof(Message15),
typeof(Message16),
typeof(Message17),
typeof(Message18),
typeof(Message19),
typeof(Message20),
typeof(Message21),
typeof(Message22)
};
Dictionary <Type, TaskCompletionSource <bool> > tasksCompleted = messageTypes.ToDictionary(k => k, v => new TaskCompletionSource <bool>());
var busControl = Bus.Factory.CreateUsingAmazonSqs(cfg =>
{
BusTestFixture.ConfigureBusDiagnostics(cfg);
cfg.Host(new Uri("amazonsqs://localhost:4566"), h =>
{
h.AccessKey("admin");
h.SecretKey("admin");
h.Config(new AmazonSimpleNotificationServiceConfig {
ServiceURL = "http://localhost:4566"
});
h.Config(new AmazonSQSConfig {
ServiceURL = "http://localhost:4566"
});
});
Func <object, Task> receiveTask = t =>
{
tasksCompleted[t.GetType()].SetResult(true);
return(TaskUtil.Completed);
};
cfg.ReceiveEndpoint("long_multi_subs_queue", e =>
{
e.Handler <Message0>(async c => await receiveTask(c.Message));
e.Handler <Message1>(async c => await receiveTask(c.Message));
e.Handler <Message2>(async c => await receiveTask(c.Message));
e.Handler <Message3>(async c => await receiveTask(c.Message));
e.Handler <Message4>(async c => await receiveTask(c.Message));
e.Handler <Message5>(async c => await receiveTask(c.Message));
e.Handler <Message6>(async c => await receiveTask(c.Message));
e.Handler <Message7>(async c => await receiveTask(c.Message));
e.Handler <Message8>(async c => await receiveTask(c.Message));
e.Handler <Message9>(async c => await receiveTask(c.Message));
e.Handler <Message10>(async c => await receiveTask(c.Message));
e.Handler <Message11>(async c => await receiveTask(c.Message));
e.Handler <Message12>(async c => await receiveTask(c.Message));
e.Handler <Message13>(async c => await receiveTask(c.Message));
e.Handler <Message14>(async c => await receiveTask(c.Message));
e.Handler <Message15>(async c => await receiveTask(c.Message));
e.Handler <Message16>(async c => await receiveTask(c.Message));
e.Handler <Message17>(async c => await receiveTask(c.Message));
e.Handler <Message18>(async c => await receiveTask(c.Message));
e.Handler <Message19>(async c => await receiveTask(c.Message));
e.Handler <Message20>(async c => await receiveTask(c.Message));
e.Handler <Message21>(async c => await receiveTask(c.Message));
e.Handler <Message22>(async c => await receiveTask(c.Message));
});
});
await busControl.StartAsync();
IEnumerable <Task> publishTasks = messageTypes.Select(m => busControl.Publish(Activator.CreateInstance(m)));
await Task.WhenAll(publishTasks);
IEnumerable <Task <bool> > awaitTasks = tasksCompleted.Values.Select(async t => await t.Task.OrTimeout(TimeSpan.FromSeconds(20)));
await Task.WhenAll(awaitTasks);
await busControl.StopAsync();
}
public async Task Should_update_the_filter_expression()
{
var topicName = "masstransit.azure.servicebus.core.tests.topologytesttypes/messagea";
var subscriptionName = "input-message-a";
var managementClient = Configuration.GetManagementClient();
await managementClient.DeleteTopicAsync(topicName);
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
var bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
x.ReceiveEndpoint("subscription-input-queue", e =>
{
e.Subscribe <MessageA>(subscriptionName, s => s.Filter = new SqlFilter("0 = 1"));
});
});
var busHandle = await bus.StartAsync();
await busHandle.StopAsync(new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
IList <RuleDescription> rules = await managementClient.GetRulesAsync(topicName, subscriptionName);
Assert.That(rules.Count, Is.EqualTo(1));
Assert.That(rules[0].Filter, Is.InstanceOf <SqlFilter>());
var filter = rules[0].Filter as SqlFilter;
Assert.That(filter.SqlExpression, Is.EqualTo("0 = 1"));
bus = Bus.Factory.CreateUsingAzureServiceBus(x =>
{
BusTestFixture.ConfigureBusDiagnostics(x);
x.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
x.ReceiveEndpoint("subscription-input-queue", e =>
{
e.Subscribe <MessageA>(subscriptionName, s => s.Filter = new SqlFilter("1 = 1"));
});
});
busHandle = await bus.StartAsync();
await busHandle.StopAsync(new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
rules = await managementClient.GetRulesAsync(topicName, subscriptionName);
Assert.That(rules.Count, Is.EqualTo(1));
Assert.That(rules[0].Filter, Is.InstanceOf <SqlFilter>());
filter = rules[0].Filter as SqlFilter;
Assert.That(filter.SqlExpression, Is.EqualTo("1 = 1"));
}