public async Task Should_Implicit_Forward_Context_On_Publish() { /* Setup */ using (var publisher = TestClientFactory.CreateNormal()) using (var firstSubscriber = TestClientFactory.CreateNormal()) using (var secondSubscriber = TestClientFactory.CreateNormal()) { var firstCtxTcs = new TaskCompletionSource <MessageContext>(); var secondCtxTcs = new TaskCompletionSource <MessageContext>(); firstSubscriber.SubscribeAsync <BasicMessage>((msg, i) => { firstCtxTcs.SetResult(i); firstSubscriber.PublishAsync(new SimpleMessage()); return(firstCtxTcs.Task); }); secondSubscriber.SubscribeAsync <SimpleMessage>((msg, i) => { secondCtxTcs.SetResult(i); return(secondCtxTcs.Task); }); /* Test */ publisher.PublishAsync <BasicMessage>(); Task.WaitAll(firstCtxTcs.Task, secondCtxTcs.Task); /* Assert */ Assert.Equal(firstCtxTcs.Task.Result.GlobalRequestId, secondCtxTcs.Task.Result.GlobalRequestId); } }
public async Task Should_Be_Able_To_Publish_Message_After_Failed_Publish() { using (var firstClient = TestClientFactory.CreateNormal()) using (var secondClient = TestClientFactory.CreateNormal()) { /* Setup */ var tcs = new TaskCompletionSource <bool>(); firstClient.SubscribeAsync <SimpleMessage>((message, context) => { tcs.TrySetResult(true); return(Task.FromResult(true)); }); /* Test */ try { await secondClient.PublishAsync(new SimpleMessage(), configuration : cfg => cfg.WithExchange(e => e.WithType(ExchangeType.Direct))); } catch (Exception) { await Task.Delay(50); Assert.False(tcs.Task.IsCompleted); } secondClient.PublishAsync(new SimpleMessage()); await tcs.Task; /* Assert */ Assert.True(true); } }
public void Should_Be_Able_To_Perform_Subscribe_For_Multiple_Types() { /* Setup */ using (var subscriber = TestClientFactory.CreateNormal()) using (var publisher = TestClientFactory.CreateNormal()) { var basicTcs = new TaskCompletionSource <BasicMessage>(); var simpleTcs = new TaskCompletionSource <SimpleMessage>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { basicTcs.SetResult(message); return(Task.FromResult(true)); }); subscriber.SubscribeAsync <SimpleMessage>((message, context) => { simpleTcs.SetResult(message); return(Task.FromResult(true)); }); /* Test */ publisher.PublishAsync <BasicMessage>(); publisher.PublishAsync <SimpleMessage>(); Task.WaitAll(basicTcs.Task, simpleTcs.Task); /* Assert */ Assert.True(true, "Successfully recieved messages."); } }
public async Task Should_Successfully_Perform_Nested_Requests() { /* Setup */ using (var requester = TestClientFactory.CreateNormal()) using (var firstResponder = TestClientFactory.CreateNormal()) using (var secondResponder = TestClientFactory.CreateNormal()) { var payload = Guid.NewGuid(); firstResponder.RespondAsync <FirstRequest, FirstResponse>(async(req, i) => { var secondResp = await firstResponder.RequestAsync <SecondRequest, SecondResponse>(new SecondRequest()); return(new FirstResponse { Infered = secondResp.Source }); }); secondResponder.RespondAsync <SecondRequest, SecondResponse>((req, i) => Task.FromResult(new SecondResponse { Source = payload }) ); /* Test */ var response = await requester.RequestAsync <FirstRequest, FirstResponse>(new FirstRequest()); /* Assert */ Assert.Equal(expected: payload, actual: response.Infered); } }
public async Task Should_Be_Able_To_Perform_Multiple_Pub_Subs() { /* Setup */ using (var subscriber = TestClientFactory.CreateNormal()) using (var publisher = TestClientFactory.CreateNormal()) { const int numberOfCalls = 100; var recived = 0; var recievedTcs = new TaskCompletionSource <bool>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { Interlocked.Increment(ref recived); if (numberOfCalls == recived) { recievedTcs.SetResult(true); } return(Task.FromResult(true)); }); /* Test */ var sw = Stopwatch.StartNew(); for (int i = 0; i < numberOfCalls; i++) { publisher.PublishAsync <BasicMessage>(); } await recievedTcs.Task; sw.Stop(); /* Assert */ Assert.True(true, $"Completed {numberOfCalls} in {sw.ElapsedMilliseconds} ms."); } }
public async Task Should_Just_Work() { /* Setup */ using (var requester = TestClientFactory.CreateNormal()) using (var responder = TestClientFactory.CreateNormal()) { const int numberOfCalls = 10000; var array = new Task[numberOfCalls]; responder.RespondAsync <FirstRequest, FirstResponse>((req, i) => Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() }) ); /* Test */ var sw = new Stopwatch(); sw.Start(); for (var i = 0; i < numberOfCalls; i++) { var response = requester.RequestAsync <FirstRequest, FirstResponse>(); array[i] = response; } Task.WaitAll(array); sw.Stop(); var ids = array .OfType <Task <FirstResponse> >() .Select(b => b.Result.Infered) .Where(id => id != Guid.Empty) .Distinct() .ToList(); /* Assert */ Assert.Equal(expected: numberOfCalls, actual: ids.Count); } }
public async Task Should_Retry_And_Leave_Requester_Hanging_On_Rpc() { using (var requester = TestClientFactory.CreateNormal <AdvancedMessageContext>()) using (var responder = TestClientFactory.CreateNormal <AdvancedMessageContext>()) { var delay = TimeSpan.FromSeconds(1); var hasBeenDelayed = false; var firstRecieved = DateTime.MinValue; var secondRecieved = DateTime.MinValue; responder.RespondAsync <BasicRequest, BasicResponse>((request, context) => { if (!hasBeenDelayed) { firstRecieved = DateTime.Now; hasBeenDelayed = true; context.RetryLater(delay); return(Task.FromResult <BasicResponse>(null)); } secondRecieved = DateTime.Now; return(Task.FromResult(new BasicResponse())); }); /* Test */ var response = await requester.RequestAsync <BasicRequest, BasicResponse>(); var actualDelay = secondRecieved - firstRecieved; await Task.Delay(80); /* Assert */ Assert.Equal(expected: delay.Seconds, actual: actualDelay.Seconds); } }
public async Task Should_Not_Throw_If_Response_Is_Handled_Within_Time_Limit() { /* Setup */ var requester = TestClientFactory.CreateNormal(ioc => { ioc.AddSingleton(p => { var cfg = RawRabbitConfiguration.Local; cfg.RequestTimeout = TimeSpan.FromMilliseconds(200); return(cfg); }); }); using (var responder = TestClientFactory.CreateNormal()) using (requester) { responder.RespondAsync <FirstRequest, FirstResponse>((request, context) => { return(Task.FromResult(new FirstResponse())); }, cfg => cfg.WithQueue(q => q.WithAutoDelete())); /* Test */ await requester.RequestAsync <FirstRequest, FirstResponse>(); /* Assert */ Assert.True(true, "Response recieved without throwing."); } }
public async Task Should_Interupt_Task_After_Timeout_Not_Met() { /* Setup */ var requester = TestClientFactory.CreateNormal(ioc => { ioc.AddSingleton(p => { var cfg = RawRabbitConfiguration.Local; cfg.RequestTimeout = TimeSpan.FromMilliseconds(200); return(cfg); }); }); using (var responder = TestClientFactory.CreateNormal()) using (requester) { responder.RespondAsync <FirstRequest, FirstResponse>((request, context) => { return(Task .Run(() => Task.Delay(250)) .ContinueWith(t => new FirstResponse())); }, cfg => cfg.WithQueue(q => q.WithAutoDelete())); /* Test */ /* Assert */ await Assert.ThrowsAsync <TimeoutException>(() => requester.RequestAsync <FirstRequest, FirstResponse>()); } }
public async Task Should_Work_When_Not_Awaiting_One_Response_At_A_Time() { /* Setup */ using (var requester = TestClientFactory.CreateNormal()) using (var responder = TestClientFactory.CreateNormal()) { const int numberOfCalls = 10; var tasks = new Task[numberOfCalls]; responder.RespondAsync <FirstRequest, FirstResponse>((req, i) => Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() }), cfg => cfg.WithQueue(q => q.WithAutoDelete())); /* Test */ for (int i = 0; i < numberOfCalls; i++) { var responseTask = requester.RequestAsync <FirstRequest, FirstResponse>(); tasks[i] = responseTask; } Task.WaitAll(tasks); var ids = tasks .OfType <Task <FirstResponse> >() .Select(t => t.Result.Infered) .Distinct() .ToList(); /* Assert */ Assert.Equal(expected: numberOfCalls, actual: ids.Count); } }
public async Task Should_Honor_Custom_Config() { /* Setup */ using (var client = TestClientFactory.CreateNormal(ioc => ioc .AddSingleton <IConfigurationEvaluator, AttributeConfigEvaluator>() )) { var tcs = new TaskCompletionSource <AttributedMessage>(); client.SubscribeAsync <AttributedMessage>((message, context) => { tcs.TrySetResult(message); return(Task.FromResult(true)); }, c => c .WithRoutingKey("special") .WithExchange(e => e.WithName("special"))); /* Test */ await client.PublishAsync(new AttributedMessage(), configuration : c => c.WithRoutingKey("special").WithExchange(e => e.WithName("special"))); await tcs.Task; /* Assert */ Assert.True(true, "Routing successful."); } }
public async Task Should_Send_Message_Context_Correctly() { /* Setup */ var expectedId = Guid.NewGuid(); var contextProvider = new MessageContextProvider <MessageContext>(new JsonSerializer(), () => new MessageContext { GlobalRequestId = expectedId }); using (var subscriber = TestClientFactory.CreateNormal()) using (var publisher = TestClientFactory.CreateNormal(collection => collection.AddSingleton <IMessageContextProvider <MessageContext> >(contextProvider))) { var subscribeTcs = new TaskCompletionSource <Guid>(); subscriber.SubscribeAsync <BasicMessage>((msg, c) => { subscribeTcs.SetResult(c.GlobalRequestId); return(subscribeTcs.Task); }); /* Test */ publisher.PublishAsync <BasicMessage>(); await subscribeTcs.Task; /* Assert */ Assert.Equal(expected: expectedId, actual: subscribeTcs.Task.Result); } }
public async Task Should_Be_Able_To_Subscribe_Without_Any_Additional_Config() { /* Setup */ using (var publisher = TestClientFactory.CreateNormal()) using (var subscriber = TestClientFactory.CreateNormal()) { var message = new BasicMessage { Prop = "Hello, world!" }; var recievedTcs = new TaskCompletionSource <BasicMessage>(); subscriber.SubscribeAsync <BasicMessage>((msg, info) => { if (msg.Prop == message.Prop) { recievedTcs.SetResult(msg); } return(Task.FromResult(true)); }); /* Test */ publisher.PublishAsync(message); await recievedTcs.Task; /* Assert */ Assert.Equal(expected: message.Prop, actual: recievedTcs.Task.Result.Prop); } }
public void Should_Be_Able_To_Deliver_Messages_To_Unique_Subscribers() { /* Setup */ using (var firstSubscriber = TestClientFactory.CreateNormal()) using (var secondSubscriber = TestClientFactory.CreateNormal()) using (var publisher = TestClientFactory.CreateNormal()) { var firstTcs = new TaskCompletionSource <bool>(); var secondTcs = new TaskCompletionSource <bool>(); firstSubscriber.SubscribeAsync <BasicMessage>((message, context) => { firstTcs.SetResult(true); return(Task.FromResult(true)); }, cfg => cfg.WithSubscriberId("first_subscriber")); secondSubscriber.SubscribeAsync <BasicMessage>((message, context) => { secondTcs.SetResult(true); return(Task.FromResult(true)); }, cfg => cfg.WithSubscriberId("second_subscriber")); /* Test */ var ackTask = publisher.PublishAsync <BasicMessage>(); Task.WaitAll(ackTask, firstTcs.Task, secondTcs.Task); /* Assert */ Assert.True(true, "Published and subscribe sucessfull."); } }
public async Task Should_Be_Able_To_Nack_On_Subscribe() { /* Setup */ using (var subscriber = TestClientFactory.CreateNormal <AdvancedMessageContext>()) using (var secondSubscriber = TestClientFactory.CreateNormal <AdvancedMessageContext>()) using (var publisher = TestClientFactory.CreateNormal <AdvancedMessageContext>()) { var callcount = 0; var subscribeTcs = new TaskCompletionSource <bool>(); var secondSubscribeTcs = new TaskCompletionSource <bool>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { Interlocked.Increment(ref callcount); context?.Nack(); subscribeTcs.TrySetResult(true); return(Task.FromResult(true)); }); secondSubscriber.SubscribeAsync <BasicMessage>((message, context) => { secondSubscribeTcs.TrySetResult(true); return(Task.FromResult(true)); }); Task.WaitAll( publisher.PublishAsync <BasicMessage>(), subscribeTcs.Task, secondSubscribeTcs.Task ); TestChannel.QueueDelete("basicmessage"); Assert.Equal(expected: 1, actual: callcount); } }
public void Should_Throw_When_Subscribed_Not_Initialized_Queue() { using (var client = TestClientFactory.CreateNormal()) { /* Setup */ const string queueName = "not.initialized.queue"; var tcs = new TaskCompletionSource <DynamicMessage>(); /* Test */ Assert.Throws <AggregateException>(() => client.SubscribeAsync <DynamicMessage>((message, context) => { tcs.TrySetResult(message); return(Task.FromResult(true)); }, cfg => cfg .WithQueue(q => q .AssumeInitialized() .WithName(queueName)) )); Assert.False(tcs.Task.IsCompleted); } }
public async Task Should_Forward_Context_On_Rpc_To_Publish() { /* Setup */ using (var requester = TestClientFactory.CreateNormal()) using (var firstResponder = TestClientFactory.CreateNormal()) using (var firstSubscriber = TestClientFactory.CreateNormal()) { var tcs = new TaskCompletionSource <bool>(); MessageContext firstContext = null; MessageContext secondContext = null; firstResponder.RespondAsync <FirstRequest, FirstResponse>(async(req, c) => { firstContext = c; await firstResponder.PublishAsync(new BasicMessage(), c.GlobalRequestId); return(new FirstResponse()); }); firstSubscriber.SubscribeAsync <BasicMessage>((req, c) => { secondContext = c; tcs.SetResult(true); return(tcs.Task); }); /* Test */ requester.RequestAsync <FirstRequest, FirstResponse>(); await tcs.Task; /* Assert */ Assert.Equal(firstContext.GlobalRequestId, secondContext.GlobalRequestId); } }
public async Task Should_Be_Able_To_Subscibe_To_Pure_Json_Message() { var conventions = new NamingConventions(); using (var client = TestClientFactory.CreateNormal(ioc => ioc.AddSingleton <INamingConventions>(c => conventions))) { /* Setup */ var tcs = new TaskCompletionSource <BasicMessage>(); var subscription = client.SubscribeAsync <BasicMessage>((message, context) => { tcs.TrySetResult(message); return(Task.FromResult(true)); }); var uniqueValue = Guid.NewGuid().ToString(); var jsonMsg = JsonConvert.SerializeObject(new BasicMessage { Prop = uniqueValue }); /* Test */ TestChannel.BasicPublish( conventions.ExchangeNamingConvention(typeof(BasicMessage)), conventions.QueueNamingConvention(typeof(BasicMessage)), true, null, Encoding.UTF8.GetBytes(jsonMsg)); await tcs.Task; /* Assert */ Assert.Equal(uniqueValue, tcs.Task.Result.Prop); } }
public void Should_Be_Able_To_Delivery_Message_To_Multiple_Subscribers_On_Same_Host() { /* Setup */ using (var subscriber = TestClientFactory.CreateNormal()) using (var publisher = TestClientFactory.CreateNormal()) { var firstTcs = new TaskCompletionSource <bool>(); var secondTcs = new TaskCompletionSource <bool>(); subscriber.SubscribeAsync <BasicMessage>((message, context) => { firstTcs.SetResult(true); return(Task.FromResult(true)); }); subscriber.SubscribeAsync <BasicMessage>((message, context) => { secondTcs.SetResult(true); return(Task.FromResult(true)); }); /* Test */ var ackTask = publisher.PublishAsync <BasicMessage>(); Task.WaitAll(ackTask, firstTcs.Task, secondTcs.Task); /* Assert */ Assert.True(true, "Published and subscribe sucessfull."); } }
public async Task Should_Use_Guest_Credentials_By_Default() { /* Setup */ /* Test */ var b = TestClientFactory.CreateNormal(); b.Dispose(); /* Assert */ Assert.True(true, "Does not throw."); }
public async Task Should_Work_For_Rpc() { /* Setup */ using (var client = TestClientFactory.CreateNormal(ioc => ioc.AddSingleton <IConfigurationEvaluator, AttributeConfigEvaluator>())) { client.RespondAsync <AttributedRequest, AttributedResponse>((message, context) => Task.FromResult(new AttributedResponse()) ); /* Test */ await client.RequestAsync <AttributedRequest, AttributedResponse>(); /* Assert */ Assert.True(true, "Routing successful."); } }
public async Task Should_Give_Clear_Error_Message_If_User_Does_Not_Exist() { /* Setup */ var config = new RawRabbitConfiguration { Username = "******", Password = "******", Hostnames = { "localhost" }, VirtualHost = "/", Port = 5672 }; /* Test */ /* Assert */ Assert.ThrowsAny <AuthenticationFailureException>(() => TestClientFactory.CreateNormal(ioc => ioc.AddSingleton(p => config))); }
public async Task Should_Be_Able_To_Subscribe_Initialized_Queue_And_Exchange() { using (var client = TestClientFactory.CreateNormal()) { /* Setup */ const string exchangeName = "initialized.exchange"; const string queueName = "initialized.queue"; try { TestChannel.ExchangeDeclare(exchangeName, RabbitMQ.Client.ExchangeType.Fanout); TestChannel.QueueDeclare(queueName, true, false, false); var tcs = new TaskCompletionSource <DynamicMessage>(); client.SubscribeAsync <DynamicMessage>((message, context) => { tcs.TrySetResult(message); return(Task.FromResult(true)); }, cfg => cfg .WithQueue(q => q .AssumeInitialized() .WithName(queueName)) .WithSubscriberId(string.Empty) .WithExchange(e => e .AssumeInitialized() .WithName(exchangeName))); /* Test */ await client.PublishAsync(new DynamicMessage { Body = new { IsDynamic = true } }, configuration : cfg => cfg .WithExchange(e => e .AssumeInitialized() .WithName(exchangeName))); await tcs.Task; /* Assert */ Assert.True(tcs.Task.Result.Body.IsDynamic); } finally { /* Teardown */ TestChannel.QueueDelete(queueName); TestChannel.ExchangeDelete(exchangeName); } } }
public async Task Should_Be_Able_To_Nack_Message() { /* Setup */ using (var firstResponder = TestClientFactory.CreateNormal <AdvancedMessageContext>()) using (var secondResponder = TestClientFactory.CreateNormal <AdvancedMessageContext>()) using (var requester = TestClientFactory.CreateNormal <AdvancedMessageContext>()) { var hasBeenNacked = false; firstResponder.RespondAsync <BasicRequest, BasicResponse>((request, context) => { BasicResponse response = null; if (!hasBeenNacked) { context?.Nack(); hasBeenNacked = true; } else { response = new BasicResponse(); } return(Task.FromResult(response)); }, c => c.WithNoAck(false)); secondResponder.RespondAsync <BasicRequest, BasicResponse>((request, context) => { BasicResponse response = null; if (!hasBeenNacked) { context?.Nack(); hasBeenNacked = true; } else { response = new BasicResponse(); } return(Task.FromResult(response)); }, c => c.WithNoAck(false)); /* Test */ var result = await requester.RequestAsync <BasicRequest, BasicResponse>(new BasicRequest(), configuration : cfg => cfg .WithReplyQueue( q => q.WithName("special_reply_queue"))); /* Assert */ Assert.NotNull(result); Assert.True(hasBeenNacked); } }
public async Task Should_Stop_Subscribe_When_Subscription_Is_Disposed() { /* Setup */ using (var publisher = TestClientFactory.CreateNormal()) using (var subscriber = TestClientFactory.CreateNormal()) { var firstMessage = new BasicMessage { Prop = "Value" }; var secondMessage = new BasicMessage { Prop = "AnotherValue" }; var firstRecievedTcs = new TaskCompletionSource <BasicMessage>(); var secondRecievedTcs = new TaskCompletionSource <BasicMessage>(); var recievedCount = 0; var subscription = subscriber.SubscribeAsync <BasicMessage>((message, context) => { recievedCount++; if (!firstRecievedTcs.Task.IsCompleted) { firstRecievedTcs.SetResult(message); } return(Task.FromResult(true)); }, cfg => cfg.WithQueue(q => q.WithAutoDelete(false))); /* Test */ publisher.PublishAsync(firstMessage); await firstRecievedTcs.Task; subscription.Dispose(); var recievedAfterFirstPublish = recievedCount; publisher.PublishAsync(secondMessage); await Task.Delay(20); publisher.SubscribeAsync <BasicMessage>((message, context) => { secondRecievedTcs.SetResult(message); return(Task.FromResult(true)); }, cfg => cfg.WithQueue(q => q.WithAutoDelete(false))); await secondRecievedTcs.Task; TestChannel.QueueDelete(subscription.QueueName); /* Assert */ Assert.Equal(recievedAfterFirstPublish, recievedCount); Assert.Equal(firstRecievedTcs.Task.Result.Prop, firstMessage.Prop); Assert.Equal(secondRecievedTcs.Task.Result.Prop, secondMessage.Prop); } }
public async Task Should_Successfully_Retry_With_Different_TimeSpans() { /* Setup */ using (var subscriber = TestClientFactory.CreateNormal <AdvancedMessageContext>()) using (var publisher = TestClientFactory.CreateNormal <AdvancedMessageContext>()) { var recived = new List <DateTime>(); var redelivered = new List <DateTime>(); var allRedelivered = new TaskCompletionSource <bool>(); var recievedCount = 0; subscriber.SubscribeAsync <BasicMessage>((message, context) => { recievedCount++; if (recievedCount <= 3) { recived.Add(DateTime.Now); context.RetryLater(TimeSpan.FromSeconds(recievedCount)); } else { redelivered.Add(DateTime.Now); if (redelivered.Count == 3) { allRedelivered.SetResult(true); } } return(Task.FromResult(true)); }); /* Test */ await publisher.PublishAsync(new BasicMessage { Prop = "I'm about to be reborn!" }); await publisher.PublishAsync(new BasicMessage { Prop = "I'm about to be reborn!" }); await publisher.PublishAsync(new BasicMessage { Prop = "I'm about to be reborn!" }); await allRedelivered.Task; /* Assert */ for (var i = 0; i < 3; i++) { Assert.Equal(expected: (redelivered[i] - recived[i]).Seconds, actual: i + 1); } } }
public async Task Should_Be_Able_To_Use_Priority() { /* Setup */ using (var subscriber = TestClientFactory.CreateNormal()) using (var publisher = TestClientFactory.CreateNormal()) { var prioritySent = false; var queueBuilt = new TaskCompletionSource <bool>(); var priorityTcs = new TaskCompletionSource <BasicMessage>(); subscriber.SubscribeAsync <BasicMessage>(async(message, context) => { await queueBuilt.Task; if (!prioritySent) { await subscriber.PublishAsync(new BasicMessage { Prop = "I am important!" }, configuration: cfg => cfg.WithProperties(p => { p.Priority = 3; })); prioritySent = true; } else { priorityTcs.TrySetResult(message); } }, cfg => cfg .WithQueue(q => q.WithArgument(QueueArgument.MaxPriority, 3)) .WithSubscriberId("priority") .WithPrefetchCount(1)); /* Test */ await publisher.PublishAsync(new BasicMessage { Prop = "I will be delivered" }); await publisher.PublishAsync(new BasicMessage { Prop = "Someone will pass me in the queue" }, configuration : cfg => cfg.WithProperties(p => p.Priority = 0)); queueBuilt.SetResult(true); await priorityTcs.Task; /* Asset */ Assert.Equal(expected: "I am important!", actual: priorityTcs.Task.Result.Prop); } }
public async Task Should_Run_Basic_Return_When_The_Manatory_Set_After_Failed_Publish() { /* Setup */ using (var client = TestClientFactory.CreateNormal()) { var tcs = new TaskCompletionSource <bool>(); /* Test */ await client.PublishAsync(new SimpleMessage(), configuration : cfg => cfg .WithMandatoryDelivery((obj, evt) => { tcs.SetResult(true); })); /* Assert */ Assert.True(tcs.Task.Result); } }
public async Task Should_Throw_Exception_To_Requester_If_Responder_Throws_Async() { /* Setup */ using (var requester = TestClientFactory.CreateNormal()) using (var responder = TestClientFactory.CreateNormal()) { responder.RespondAsync <BasicRequest, BasicResponse>((request, context) => { throw new NotSupportedException("I'll throw this"); }); /* Test */ /* Assert */ var e = await Assert.ThrowsAsync <MessageHandlerException>(() => requester.RequestAsync <BasicRequest, BasicResponse>()); Assert.NotNull(e); } }
public BulkGetTests() { var basicQueueBase = "basicmessage"; var simpleQueueBase = "simplemessage"; var firstSuffix = "first_subscriber"; var secondSuffix = "second_subscriber"; _firstBasicQueue = $"{basicQueueBase}_{firstSuffix}"; _secondBasicQueue = $"{basicQueueBase}_{secondSuffix}"; _firstSimpleQueue = $"{simpleQueueBase}_{firstSuffix}"; using (var subscriber = TestClientFactory.CreateNormal()) { subscriber.SubscribeAsync <BasicMessage>((message, context) => Task.FromResult(true), cfg => cfg.WithSubscriberId(firstSuffix).WithQueue(q => q.WithAutoDelete(false))); subscriber.SubscribeAsync <BasicMessage>((message, context) => Task.FromResult(true), cfg => cfg.WithSubscriberId(secondSuffix).WithQueue(q => q.WithAutoDelete(false))); subscriber.SubscribeAsync <SimpleMessage>((message, context) => Task.FromResult(true), cfg => cfg.WithSubscriberId(firstSuffix).WithQueue(q => q.WithAutoDelete(false))); } }