static void Main(string[] args) { var broker = new SqlServerServiceBroker("Server=.;Integrated Security=SSPI;Initial Catalog=WorkWork"); /* var workQueue = broker.OpenChannel<string>(); Task.Factory.StartNew(() => { for(var i = 0; i != 10; ++i) { workQueue.Send(i.ToString()); Thread.Sleep(250); } workQueue.Send("Bye."); }, TaskCreationOptions.LongRunning); for(var done = false; !done;) { workQueue.TryReceive(x => { if(x == "Bye.") done = true; Console.WriteLine(x); }); } */ var q2 = broker.OpenChannel<Message>(); for(;;) q2.Send(Message.NewMessage(Console.ReadLine())); }
public async Task BeginConversationTimerAsync_ArgumentsCannotBeNull() { // Arrange var provider = new SqlServerServiceBroker(connection); // Act Func<Task> call = async () => await provider.BeginConversationTimerAsync(null); // Assert await Assert.ThrowsAsync<ArgumentNullException>("arguments", call); }
public async Task BeginTransactionAsync_ThrowsInvalidOperationException_WhileTransactionActive() { // Arrange var provider = new SqlServerServiceBroker(connection); var transaction = default(IServiceBrokerTransaction); // Act Func<Task> call1 = async () => { try { provider.UseTransaction(connection.BeginTransaction()); transaction = await provider.BeginTransactionAsync(); } finally { provider.UseTransaction(null); } }; Func<Task> call2 = async () => { try { transaction = await provider.BeginTransactionAsync(); transaction = await provider.BeginTransactionAsync(); } finally { provider.UseTransaction(null); } }; // Assert await Assert.ThrowsAsync<InvalidOperationException>(call1); Assert.Null(transaction); await Assert.ThrowsAsync<InvalidOperationException>(call2); Assert.NotNull(transaction); }
public async Task BeginDialogAsync_RespectsBrokerInstanceCurrentDatabase() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var arguments = new BeginDialogArguments("InitiatorService", "TargetService") { BrokerInstance = BrokerInstance.CurrentDatabase, }; // Act var conversationHandle = await provider.BeginDialogAsync(arguments); var sql = @" SELECT CAST(e.far_broker_instance AS uniqueidentifier) AS [actual], (SELECT service_broker_guid FROM sys.databases WHERE database_id = DB_ID()) AS [expected] FROM sys.conversation_endpoints e WHERE conversation_handle = @handle "; var results = await connection.QueryAsync(sql, new { handle = conversationHandle.Value }); var conversation = results.Single(); // Assert Assert.Equal(conversation.expected, conversation.actual); }
public async Task BeginConversationTimerAsync_Succeeds() { // Arrange await InitializeDatabaseAsync(); var handle = await BeginDialogAsync(); var provider = new SqlServerServiceBroker(connection); var arguments = new BeginConversationTimerArguments(handle, 600); // Act await provider.BeginConversationTimerAsync(arguments); var sql = @"SELECT * FROM sys.conversation_endpoints WHERE conversation_handle = @handle"; var results = await connection.QueryAsync(sql, new { handle }); var scheduledTime = (DateTime)results.Single().dialog_timer; // Assert Assert.True(scheduledTime > DateTime.Now); }
public async Task SendAsync_RespectsMessageType() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await provider.BeginDialogAsync( new BeginDialogArguments("InitiatorService", "TargetService") { ContractName = "TestContract", }); // Act await provider.SendAsync(new SendArguments(handle) { MessageTypeName = "TestMessageType", }); var received = await connection.QueryAsync("SELECT * FROM [TargetQueue] WITH (NOLOCK)"); // Assert Assert.Equal("TestMessageType", received.Single().message_type_name); }
public async Task ReceiveAsync_UsesTransaction() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }); // Act var transaction = await provider.BeginTransactionAsync(); var beforeRollback = await provider.ReceiveAsync(new ReceiveArguments("TargetQueue")); transaction.Rollback(); var afterRollback = await provider.ReceiveAsync(new ReceiveArguments("TargetQueue")); // Assert Assert.NotEmpty(beforeRollback); Assert.NotEmpty(afterRollback); }
public async Task ReceiveAsync_RespectsWaitFor() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); // Act var receive = provider.ReceiveAsync(new ReceiveArguments("TargetQueue") { WaitFor = MillisecondTimeout.Unlimited, }); Thread.Sleep(1000); // Assert Assert.False(receive.IsCompleted); }
public async Task ReceiveAsync_RespectsQueue() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }); // Act var receive = await provider.ReceiveAsync(new ReceiveArguments("TargetQueue") { }); // Assert Assert.True(receive.Any()); }
public async Task BeginDialogAsync_UsesTransaction() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var arguments = new BeginDialogArguments("InitiatorService", "TargetService"); var handle = default(ConversationHandle); // Act using (var transaction = await provider.BeginTransactionAsync()) { handle = await provider.BeginDialogAsync(arguments); transaction.Rollback(); } var sql = @"SELECT * FROM sys.conversation_endpoints WHERE conversation_handle = @handle"; var results = await connection.QueryAsync(sql, new { handle = handle.Value }); // Assert Assert.Empty(results); }
public async Task BeginDialogAsync_RespectsEncryptionOn() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var arguments = new BeginDialogArguments("InitiatorService", "TargetService") { Encryption = true, }; // Act var conversationHandle = await provider.BeginDialogAsync(arguments); var sql = @" SEND ON CONVERSATION @handle; SELECT GET_TRANSMISSION_STATUS(@handle) AS [status]"; var results = await connection.QueryAsync(sql, new { handle = conversationHandle.Value }); var status = results.Single().status; // Assert Assert.StartsWith("The session keys", status); }
public async Task BeginDialogAsync_RespectsEncryptionOff() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var arguments = new BeginDialogArguments("InitiatorService", "TargetService") { Encryption = true, }; // Act var conversationHandle = await provider.BeginDialogAsync(arguments); var sql = @" SEND ON CONVERSATION @handle; SELECT * FROM sys.conversation_endpoints WHERE conversation_handle = @handle"; var results = await connection.QueryAsync(sql, new { handle = conversationHandle.Value }); var conversation = results.Single(); // Assert Assert.Equal("CO", conversation.state); Assert.Equal(Guid.Empty, conversation.outbound_session_key_identifier); Assert.Equal(Guid.Empty, conversation.inbound_session_key_identifier); }
public async Task BeginDialogAsync_RespectsRelatedConversationHandlesAndGroupIds() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var group = Guid.NewGuid(); var arguments = new BeginDialogArguments("InitiatorService", "TargetService") { Related = (ConversationGroupId)group }; // Act var conversationHandle = await provider.BeginDialogAsync(arguments); arguments.Related = conversationHandle; conversationHandle = await provider.BeginDialogAsync(arguments); var sql = @" SELECT e.conversation_group_id FROM sys.conversation_endpoints e WHERE conversation_handle = @handle "; var results = await connection.QueryAsync(sql, new { handle = conversationHandle.Value }); var conversation = results.Single(); // Assert Assert.Equal(group, conversation.conversation_group_id); }
public async Task BeginDialogAsync_RespectsLifeTime() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var arguments = new BeginDialogArguments("InitiatorService", "TargetService") { Lifetime = TimeSpan.FromHours(23), }; // Act var conversationHandle = await provider.BeginDialogAsync(arguments); var sql = @" SELECT e.lifetime FROM sys.conversation_endpoints e WHERE conversation_handle = @handle "; var results = await connection.QueryAsync(sql, new { handle = conversationHandle.Value }); var conversation = results.Single(); // Assert Assert.True(conversation.lifetime < DateTime.Now.AddDays(1).ToUniversalTime()); }
public async Task BeginDialogAsync_RespectsContract() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var arguments = new BeginDialogArguments("InitiatorService", "TargetService") { ContractName = "TestContract", }; // Act var conversationHandle = await provider.BeginDialogAsync(arguments); var sql = @" SELECT c.name FROM sys.conversation_endpoints e JOIN sys.service_contracts c ON c.service_contract_id = e.service_contract_id WHERE conversation_handle = @handle "; var results = await connection.QueryAsync(sql, new { handle = conversationHandle.Value }); var contract = results.Single(); // Assert Assert.Equal("TestContract", contract.name); }
public async Task MoveConversationAsync_Succeeds() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); var sql = @"SELECT [conversation_group_id] FROM sys.conversation_endpoints WHERE conversation_handle = @handle"; var newGroupId = await connection.ExecuteScalarAsync<Guid>(sql, new { handle }); handle = await BeginDialogAsync(); // Act await provider.MoveConversationAsync(new MoveConversationArguments(handle, newGroupId)); var actualGroupId = await connection.ExecuteScalarAsync<Guid>(sql, new { handle }); // Assert Assert.Equal(newGroupId, actualGroupId); }
public async Task MoveConversationAsync_UsesTransaction() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle1 = await BeginDialogAsync(); var handle2 = await BeginDialogAsync(); var sql = @"SELECT [conversation_group_id] FROM sys.conversation_endpoints WHERE conversation_handle = @handle"; var group1 = await connection.ExecuteScalarAsync<Guid>(sql, new { handle = handle1 }); var group2 = await connection.ExecuteScalarAsync<Guid>(sql, new { handle = handle2 }); // Act using (var transaction = await provider.BeginTransactionAsync()) { await provider.MoveConversationAsync(new MoveConversationArguments(handle1, group2)); transaction.Rollback(); } var afterRollback = await connection.ExecuteScalarAsync<Guid>(sql, new { handle = handle1 }); // Assert Assert.Equal(group1, afterRollback); }
public async Task EndConversationAsync_Succeeds() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); // Act await provider.EndConversationAsync(new EndConversationArguments(handle)); var sql = @"SELECT [state] FROM sys.conversation_endpoints WHERE conversation_handle = @handle"; var results = await connection.QueryAsync(sql, new { handle }); // Assert Assert.Empty(results); }
public async Task ReceiveAsync_RespectsTop() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }); await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }); // Act var receive = await provider.ReceiveAsync(new ReceiveArguments("TargetQueue") { Top = 1, WaitFor = TimeSpan.FromSeconds(5), }); // Assert Assert.Equal(1, receive.Count()); }
public async Task EndConversationAsync_UsesTransaction() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); // Act using (var transaction = await provider.BeginTransactionAsync()) { await provider.EndConversationAsync(new EndConversationArguments(handle)); transaction.Rollback(); } var sql = @"SELECT [state] FROM sys.conversation_endpoints WHERE conversation_handle = @handle"; var results = await connection.QueryAsync(sql, new { handle }); // Assert Assert.NotEmpty(results); }
public async Task ReceiveAsync_RespectsPredicate_ConversationGroupId() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle1 = await BeginDialogAsync(); await connection.ExecuteAsync("SEND ON CONVERSATION @handle1;", new { handle1 }); var handle2 = await BeginDialogAsync(); await connection.ExecuteAsync("SEND ON CONVERSATION @handle2;", new { handle2 }); var groups = await connection.QueryAsync( "SELECT conversation_group_id FROM [TargetQueue] WITH (NOLOCK)"); var group = groups.Last().conversation_group_id; // Act var receive = await provider.ReceiveAsync(new ReceiveArguments("TargetQueue") { Predicate = (ConversationGroupId)group, }); // Assert Assert.Equal(group, receive.Single().ConversationGroupId.Value); }
public async Task GetConversationGroupAsync_RespectsQueue() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }); // Act var groupId = await provider.GetConversationGroupAsync(new GetConversationGroupArguments("TargetQueue") { }); // Assert Assert.True(groupId.HasValue); Assert.NotEqual(Guid.Empty, groupId.GetValueOrDefault().Value); }
public async Task ReceiveAsync_DecodesMessageBodyAsUnicode() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); await connection.ExecuteAsync("SEND ON CONVERSATION @handle (N'Hello');", new { handle }); await connection.ExecuteAsync("SEND ON CONVERSATION @handle ('Hello');", new { handle }); // Act var receive = await provider.ReceiveAsync(new ReceiveArguments("TargetQueue") { }); // Assert Assert.Equal("Hello", receive.First().Body); Assert.NotEqual("Hello", receive.Last().Body); }
public async Task GetConversationGroupAsync_UsesTransaction() { // Arrange await InitializeDatabaseAsync(); var provider1 = new SqlServerServiceBroker(connection); var provider2 = new SqlServerServiceBroker(new SqlConnection(connection.ConnectionString)); var handle = await BeginDialogAsync(); IEnumerable<ReceivedMessage> beforeRollback; IEnumerable<ReceivedMessage> afterRollback; await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }); // Act using (var transaction = await provider1.BeginTransactionAsync()) { var arguments = new GetConversationGroupArguments("TargetQueue"); var groupId = await provider1.GetConversationGroupAsync(arguments); var receiveArgs = new ReceiveArguments("TargetQueue") { Predicate = groupId.Value, WaitFor = TimeSpan.FromSeconds(1), }; beforeRollback = await provider2.ReceiveAsync(receiveArgs); transaction.Rollback(); afterRollback = await provider2.ReceiveAsync(receiveArgs); } // Assert Assert.Empty(beforeRollback); Assert.NotEmpty(afterRollback); }
public async Task SendAsync_RespectsMultipleConversationHandles() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle1 = await BeginDialogAsync(); var handle2 = await BeginDialogAsync(); // Act await provider.SendAsync(new SendArguments(handle1, handle2)); var received = await connection.QueryAsync("SELECT * FROM [TargetQueue] WITH (NOLOCK)"); // Assert Assert.Equal(2, received.Count()); }
public async Task GetTransmissionStatusAsync_ArgumentsCannotBeNull() { // Arrange var provider = new SqlServerServiceBroker(connection); // Act Func<Task> call = async () => await provider.GetTransmissionStatusAsync(null); // Assert await Assert.ThrowsAsync<ArgumentNullException>("arguments", call); }
public async Task SendAsync_RespectsMessageBody() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); var body = "Quoth the Sandler, Barrymore"; // Act await provider.SendAsync(new SendArguments(handle) { MessageBody = body, }); var received = await connection.QueryAsync("SELECT CAST(message_body AS nvarchar(max)) AS message_body FROM [TargetQueue] WITH (NOLOCK)"); // Assert Assert.Equal(body, received.Single().message_body); }
public async Task GetTransmissionStatusAsync_Succeeds() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(encryption: true); await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }); // Act var status = await provider.GetTransmissionStatusAsync(new GetTransmissionStatusArguments(handle)); // Assert Assert.StartsWith("The session keys", status); }
public async Task SendAsync_UsesTransaction() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(); // Act using (var transaction = await provider.BeginTransactionAsync()) { await provider.SendAsync(new SendArguments(handle)); transaction.Rollback(); } var received = await connection.QueryAsync("SELECT * FROM [TargetQueue] WITH (NOLOCK)"); // Assert Assert.Empty(received); }
public async Task GetTransmissionStatusAsync_UsesTransaction() { // Arrange await InitializeDatabaseAsync(); var provider = new SqlServerServiceBroker(connection); var handle = await BeginDialogAsync(encryption: true); // Act using (var transaction = await provider.BeginTransactionAsync()) { await connection.ExecuteAsync("SEND ON CONVERSATION @handle;", new { handle }, transaction.UnderlyingTransaction); transaction.Rollback(); } var status = await provider.GetTransmissionStatusAsync(new GetTransmissionStatusArguments(handle)); // Assert Assert.Equal(string.Empty, status); }