public static ManagementClient GetManagementClient()
{
var hostAddress = AzureServiceBusEndpointUriCreator.Create(ServiceNamespace);
var accountSettings = new TestAzureServiceBusAccountSettings();
var keyName = accountSettings.KeyName;
var accessKey = accountSettings.SharedAccessKey;
var hostConfigurator = new ServiceBusHostConfigurator(hostAddress);
hostConfigurator.SharedAccessSignature(s =>
{
s.KeyName = keyName;
s.SharedAccessKey = accessKey;
s.TokenTimeToLive = accountSettings.TokenTimeToLive;
s.TokenScope = accountSettings.TokenScope;
});
var endpoint = new UriBuilder(hostAddress)
{
Path = ""
}.Uri.ToString();
var managementClient = new ManagementClient(endpoint, hostConfigurator.Settings.TokenProvider);
return(managementClient);
}
public AzureServiceBusTestFixture(string inputQueueName = null, Uri serviceUri = null, ServiceBusTokenProviderSettings settings = null)
: this(new AzureServiceBusTestHarness(
serviceUri ?? AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace, "MassTransit.Azure.ServiceBus.Core.Tests"),
settings?.KeyName ?? ((ServiceBusTokenProviderSettings) new TestAzureServiceBusAccountSettings()).KeyName,
settings?.SharedAccessKey ?? ((ServiceBusTokenProviderSettings) new TestAzureServiceBusAccountSettings()).SharedAccessKey,
inputQueueName))
{
}
public async Task Should_start_stop_and_start()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceBusNamespace = Configuration.ServiceNamespace;
var serviceUri = AzureServiceBusEndpointUriCreator.Create(
serviceBusNamespace,
"MassTransit.Azure.ServiceBus.Core.Tests"
);
var bus = MassTransit.Bus.Factory.CreateUsingAzureServiceBus(x =>
{
x.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
ConfigureBusDiagnostics(x);
x.ReceiveEndpoint("input_queue", e =>
{
e.Handler <PingMessage>(async context =>
{
await context.RespondAsync(new PongMessage());
});
});
});
await bus.StartAsync(TestCancellationToken);
try
{
await bus.CreateRequestClient <PingMessage>().GetResponse <PongMessage>(new PingMessage());
}
finally
{
await bus.StopAsync(TestCancellationToken);
}
await bus.StartAsync(TestCancellationToken);
try
{
await bus.CreateRequestClient <PingMessage>().GetResponse <PongMessage>(new PingMessage());
}
finally
{
await bus.StopAsync(TestCancellationToken);
}
}
public async Task Should_connect_subscription_endpoint()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace);
var provider = new ServiceCollection()
.AddSingleton <ILoggerFactory>(LoggerFactory)
.AddSingleton(typeof(ILogger <>), typeof(Logger <>))
.AddMassTransit(x =>
{
x.UsingAzureServiceBus((context, cfg) =>
{
cfg.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
});
}).BuildServiceProvider(true);
var depot = provider.GetRequiredService <IBusDepot>();
await depot.Start(TestCancellationToken);
try
{
var bus = provider.GetRequiredService <IBus>();
var connector = provider.GetRequiredService <ISubscriptionEndpointConnector>();
Task <ConsumeContext <PingMessage> > handled = null;
var handle = connector.ConnectSubscriptionEndpoint <PingMessage>("my-sub", e =>
{
handled = Handled <PingMessage>(e);
});
await handle.Ready;
await bus.Publish(new PingMessage());
await handled;
}
finally
{
await depot.Stop(TimeSpan.FromSeconds(30));
}
}
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_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 Sending_a_message_to_a_basic_endpoint()
: base("input_queue", AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace, "MassTransit.Azure.ServiceBus.Core.Tests"),
new BasicAzureServiceBusAccountSettings())
{
}
public Publishing_a_message_to_an_endpoint_with_a_slash()
: base(serviceUri: AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace))
{
}
public TwoScopeAzureServiceBusTestFixture(string scope = default)
{
_secondServiceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace, scope ?? "MassTransit.Tests.SecondService");
}
public async Task Should_start_stop_and_start()
{
ServiceBusTokenProviderSettings settings = new TestAzureServiceBusAccountSettings();
var serviceBusNamespace = Configuration.ServiceNamespace;
var serviceUri = AzureServiceBusEndpointUriCreator.Create(
serviceBusNamespace,
"MassTransit.Azure.ServiceBus.Core.Tests"
);
var bus = MassTransit.Bus.Factory.CreateUsingAzureServiceBus(cfg =>
{
cfg.Host(serviceUri, h =>
{
h.SharedAccessSignature(s =>
{
s.KeyName = settings.KeyName;
s.SharedAccessKey = settings.SharedAccessKey;
s.TokenTimeToLive = settings.TokenTimeToLive;
s.TokenScope = settings.TokenScope;
});
});
ConfigureBusDiagnostics(cfg);
cfg.ReceiveEndpoint("queue01", ep => ep.Consumer(() => new Consumer <Foo01>()));
cfg.ReceiveEndpoint("queue02", ep => ep.Consumer(() => new Consumer <Foo02>()));
cfg.ReceiveEndpoint("queue03", ep => ep.Consumer(() => new Consumer <Foo03>()));
cfg.ReceiveEndpoint("queue04", ep => ep.Consumer(() => new Consumer <Foo04>()));
cfg.ReceiveEndpoint("queue05", ep => ep.Consumer(() => new Consumer <Foo05>()));
cfg.ReceiveEndpoint("queue06", ep => ep.Consumer(() => new Consumer <Foo06>()));
cfg.ReceiveEndpoint("queue07", ep => ep.Consumer(() => new Consumer <Foo07>()));
cfg.ReceiveEndpoint("queue08", ep => ep.Consumer(() => new Consumer <Foo08>()));
cfg.ReceiveEndpoint("queue09", ep => ep.Consumer(() => new Consumer <Foo09>()));
cfg.ReceiveEndpoint("queue10", ep => ep.Consumer(() => new Consumer <Foo10>()));
cfg.ReceiveEndpoint("queue11", ep => ep.Consumer(() => new Consumer <Foo11>()));
cfg.ReceiveEndpoint("queue12", ep => ep.Consumer(() => new Consumer <Foo12>()));
cfg.ReceiveEndpoint("queue13", ep => ep.Consumer(() => new Consumer <Foo13>()));
cfg.ReceiveEndpoint("queue14", ep => ep.Consumer(() => new Consumer <Foo14>()));
cfg.ReceiveEndpoint("queue15", ep => ep.Consumer(() => new Consumer <Foo15>()));
cfg.ReceiveEndpoint("queue16", ep => ep.Consumer(() => new Consumer <Foo16>()));
cfg.ReceiveEndpoint("queue17", ep => ep.Consumer(() => new Consumer <Foo17>()));
cfg.ReceiveEndpoint("queue18", ep => ep.Consumer(() => new Consumer <Foo18>()));
cfg.ReceiveEndpoint("queue19", ep => ep.Consumer(() => new Consumer <Foo19>()));
cfg.ReceiveEndpoint("queue20", ep => ep.Consumer(() => new Consumer <Foo20>()));
cfg.ReceiveEndpoint("queue21", ep => ep.Consumer(() => new Consumer <Foo21>()));
cfg.ReceiveEndpoint("queue22", ep => ep.Consumer(() => new Consumer <Foo22>()));
cfg.ReceiveEndpoint("queue23", ep => ep.Consumer(() => new Consumer <Foo23>()));
cfg.ReceiveEndpoint("queue24", ep => ep.Consumer(() => new Consumer <Foo24>()));
cfg.ReceiveEndpoint("queue25", ep => ep.Consumer(() => new Consumer <Foo25>()));
cfg.ReceiveEndpoint("queue26", ep => ep.Consumer(() => new Consumer <Foo26>()));
cfg.ReceiveEndpoint("queue27", ep => ep.Consumer(() => new Consumer <Foo27>()));
cfg.ReceiveEndpoint("queue28", ep => ep.Consumer(() => new Consumer <Foo28>()));
cfg.ReceiveEndpoint("queue29", ep => ep.Consumer(() => new Consumer <Foo29>()));
cfg.ReceiveEndpoint("queue30", ep => ep.Consumer(() => new Consumer <Foo30>()));
});
await bus.StartAsync(TestCancellationToken);
try
{
}
finally
{
await bus.StopAsync(TestCancellationToken);
}
await bus.StartAsync(TestCancellationToken);
try
{
}
finally
{
await bus.StopAsync(TestCancellationToken);
}
}
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"));
}
public TwoScopeAzureServiceBusTestFixture(string scope)
{
_secondServiceUri = AzureServiceBusEndpointUriCreator.Create(Configuration.ServiceNamespace, scope);
}
