public async Task Should_properly_fail_on_exclusive_launch()
{
var harness1 = new RabbitMqTestHarness();
harness1.OnConfigureRabbitMqBus += configurator =>
{
configurator.OverrideDefaultBusEndpointQueueName("exclusively-yours");
configurator.Exclusive = true;
};
var harness2 = new RabbitMqTestHarness();
harness2.OnConfigureRabbitMqBus += configurator =>
{
configurator.OverrideDefaultBusEndpointQueueName("exclusively-yours");
configurator.Exclusive = true;
};
await harness1.Start();
try
{
Assert.That(async() => await harness2.Start(), Throws.TypeOf <RabbitMqConnectionException>());
await harness2.Stop();
}
finally
{
await Task.Delay(1000);
await harness1.Stop();
}
}
public async Task Should_not_be_allowed_twice()
{
var loggerFactory = new TestOutputLoggerFactory(true);
LogContext.ConfigureCurrentLogContext(loggerFactory);
DiagnosticListener.AllListeners.Subscribe(new DiagnosticListenerObserver());
var secondHarness = new RabbitMqTestHarness();
try
{
Assert.That(async() =>
{
using (var token = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
await secondHarness.Start(token.Token).OrCanceled(TestCancellationToken);
await secondHarness.Stop();
}
}, Throws.TypeOf <RabbitMqConnectionException>());
}
finally
{
secondHarness.Dispose();
}
}
public async Task <BusTestHarness> CreateTestHarness()
{
var harness = new RabbitMqTestHarness();
await EnsureVirtualHostExists(harness);
return(harness);
}
public async Task Should_fan_out_published_messages()
{
var endpointSettings = new EndpointSettings <IEndpointDefinition <EventConsumer> > {
InstanceId = "27"
};
var endpointDefinition = new ConsumerEndpointDefinition <EventConsumer>(endpointSettings);
var firstHarness = new RabbitMqTestHarness();
var firstConsumer = new EventConsumer(firstHarness.GetTask <ConsumeContext <SomeEvent> >());
firstHarness.OnConfigureRabbitMqBus += configurator =>
{
configurator.ReceiveEndpoint(endpointDefinition, KebabCaseEndpointNameFormatter.Instance, e =>
{
e.Consumer(() => firstConsumer);
});
};
await firstHarness.Start();
try
{
endpointSettings = new EndpointSettings <IEndpointDefinition <EventConsumer> > {
InstanceId = "42"
};
endpointDefinition = new ConsumerEndpointDefinition <EventConsumer>(endpointSettings);
var secondHarness = new RabbitMqTestHarness();
var secondConsumer = new EventConsumer(secondHarness.GetTask <ConsumeContext <SomeEvent> >());
secondHarness.OnConfigureRabbitMqBus += configurator =>
{
configurator.ReceiveEndpoint(endpointDefinition, KebabCaseEndpointNameFormatter.Instance, e =>
{
e.Consumer(() => secondConsumer);
});
};
await secondHarness.Start();
try
{
await firstHarness.Bus.Publish(new SomeEvent());
await firstConsumer.Completed;
await secondConsumer.Completed;
}
finally
{
await secondHarness.Stop();
}
}
finally
{
await firstHarness.Stop();
}
}
public async Task Setup()
{
_harness = new RabbitMqTestHarness();
_handler = _harness.Handler <A>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
await _harness.InputQueueSendEndpoint.Send(new B());
}
public RabbitMqTestFixture(RabbitMqTestHarness harness, Uri logicalHostAddress = null)
: base(harness)
{
RabbitMqTestHarness = harness;
if (logicalHostAddress != null)
{
RabbitMqTestHarness.NodeHostName = RabbitMqTestHarness.HostAddress.Host;
RabbitMqTestHarness.HostAddress = logicalHostAddress;
}
RabbitMqTestHarness.OnConfigureRabbitMqHost += ConfigureRabbitMqHost;
RabbitMqTestHarness.OnConfigureRabbitMqBus += ConfigureRabbitMqBus;
RabbitMqTestHarness.OnConfigureRabbitMqReceiveEndpoint += ConfigureRabbitMqReceiveEndpoint;
RabbitMqTestHarness.OnCleanupVirtualHost += OnCleanupVirtualHost;
}
static async Task EnsureVirtualHostExists(RabbitMqTestHarness harness)
{
var name = harness.GetHostSettings().VirtualHost;
if (string.IsNullOrWhiteSpace(name) || name == "/")
{
return;
}
using var client = new HttpClient();
var byteArray = Encoding.ASCII.GetBytes($"{harness.Username}:{harness.Password}");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
var requestUri = new UriBuilder("http", harness.HostAddress.Host, 15672, $"api/vhosts/{name}").Uri;
await client.PutAsync(requestUri, new StringContent("{}", Encoding.UTF8, "application/json"));
}
public void CreateHarness()
{
if (HarnessType == typeof(InMemoryTestHarness))
{
Harness = new InMemoryTestHarness();
}
else if (HarnessType == typeof(RabbitMqTestHarness))
{
var harness = new RabbitMqTestHarness();
Harness = harness;
harness.OnConfigureRabbitMqReceiveEndoint += x => x.BindMessageExchanges = Subscribe;
}
else if (HarnessType == typeof(ActiveMqTestHarness))
{
var harness = new ActiveMqTestHarness();
Harness = harness;
harness.OnConfigureActiveMqReceiveEndoint += x => x.BindMessageTopics = Subscribe;
}
else if (HarnessType == typeof(AzureServiceBusTestHarness))
{
var serviceUri = Credentials.AzureServiceUri;
var harness = new AzureServiceBusTestHarness(serviceUri, Credentials.AzureKeyName, Credentials.AzureKeyValue);
Harness = harness;
harness.OnConfigureServiceBusReceiveEndpoint += x => x.SubscribeMessageTopics = Subscribe;
}
else if (HarnessType == typeof(AmazonSqsTestHarness))
{
var harness = new AmazonSqsTestHarness(Credentials.AmazonRegion, Credentials.AmazonAccessKey, Credentials.AmazonSecretKey);
Harness = harness;
harness.OnConfigureAmazonSqsReceiveEndpoint += x => x.SubscribeMessageTopics = Subscribe;
}
else
{
throw new ArgumentException($"Unknown test harness type: {TypeCache.GetShortName(HarnessType)}");
}
}
public async Task Setup()
{
_harness = new RabbitMqTestHarness();
_handler = _harness.Handler <A>(async context =>
{
var endpoint = await context.GetSendEndpoint(context.SourceAddress);
await endpoint.Send(new C());
await context.Publish(new D());
});
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
await _harness.Bus.Publish(new B());
}
public async Task Should_not_be_allowed_twice()
{
var secondHarness = new RabbitMqTestHarness();
try
{
Assert.That(async() =>
{
await secondHarness.Start();
await secondHarness.Stop();
}, Throws.TypeOf <RabbitMqConnectionException>());
}
finally
{
secondHarness.Dispose();
}
}
async Task CreateVirtualHost(string name)
{
try
{
var harness = new RabbitMqTestHarness();
using var client = new HttpClient();
var byteArray = Encoding.ASCII.GetBytes($"{harness.Username}:{harness.Password}");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
var requestUri = new UriBuilder("http", harness.HostAddress.Host, 15672, $"api/vhosts/{name}").Uri;
await client.PutAsync(requestUri, new StringContent("{}", Encoding.UTF8, "application/json"));
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
public async Task Should_not_be_allowed_twice()
{
var secondHarness = new RabbitMqTestHarness();
try
{
Assert.That(async() =>
{
using (var token = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
await secondHarness.Start(token.Token);
await secondHarness.Stop();
}
}, Throws.TypeOf <RabbitMqConnectionException>());
}
finally
{
secondHarness.Dispose();
}
}
public async Task Should_not_be_allowed_twice()
{
var secondHarness = new RabbitMqTestHarness {
CleanVirtualHost = false
};
try
{
Assert.That(async() =>
{
using var token = new CancellationTokenSource(TimeSpan.FromSeconds(5));
await secondHarness.Start(token.Token).OrCanceled(TestCancellationToken);
await secondHarness.Stop();
}, Throws.TypeOf <RabbitMqConnectionException>());
}
finally
{
secondHarness.Dispose();
}
}
protected override void ConfigureRabbitMqBusHost(IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host)
{
_management = configurator.ManagementEndpoint(host);
_consumerA = RabbitMqTestHarness.Consumer <TestConsumer>();
}
protected override void ConfigureRabbitMqBus(IRabbitMqBusFactoryConfigurator configurator)
{
_configurator = configurator;
_consumerA = RabbitMqTestHarness.Consumer <TestConsumer>();
}
public async Task Show_timeline()
{
var completed = (await _completed).Message;
await RabbitMqTestHarness.OutputTimeline(TestContext.Out, x => x.Now().IncludeAddress());
}
