public async void Should_Be_Able_To_Subscribe_To_Generic_Message()
{
using (var subscriber = ZyRabbitFactory.CreateTestClient())
using (var publisher = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var doneTsc = new TaskCompletionSource <GenericMessage <int> >();
var message = new GenericMessage <int>
{
Prop = 7
};
await subscriber.SubscribeAsync <GenericMessage <int> >(received =>
{
doneTsc.TrySetResult(received);
return(Task.FromResult(0));
}
);
/* Test */
await publisher.PublishAsync(message);
await doneTsc.Task;
/* Assert */
Assert.Equal(doneTsc.Task.Result.Prop, message.Prop);
}
}
public async Task Should_Execute_Sequence_With_Multiple_Whens()
{
/* Setup */
using (var client = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions
{
Plugins = p => p
.UseStateMachine()
.UseGlobalExecutionId()
}))
{
var secondTcs = new TaskCompletionSource <SecondMessage>();
var thirdTsc = new TaskCompletionSource <ThirdMessage>();
var forthTcs = new TaskCompletionSource <ForthMessage>();
await client.SubscribeAsync <FirstMessage, MessageContext>((request, context) =>
client.PublishAsync(new SecondMessage())
);
await client.SubscribeAsync <SecondMessage, MessageContext>((request, context) =>
client.PublishAsync(new ThirdMessage())
);
await client.SubscribeAsync <ThirdMessage, MessageContext>((request, context) =>
client.PublishAsync(new ForthMessage())
);
await client.SubscribeAsync <ForthMessage, MessageContext>((request, context) =>
client.PublishAsync(new FifthMessage())
);
/* Test */
var chain = client.ExecuteSequence(c => c
.PublishAsync <FirstMessage>()
.When <SecondMessage, MessageContext>((message, context) =>
{
secondTcs.TrySetResult(message);
return(Task.FromResult(0));
})
.When <ThirdMessage, MessageContext>((message, context) =>
{
thirdTsc.TrySetResult(message);
return(Task.FromResult(0));
})
.When <ForthMessage, MessageContext>((message, context) =>
{
forthTcs.TrySetResult(message);
return(Task.FromResult(0));
})
.Complete <FifthMessage>()
);
await chain.Task;
await secondTcs.Task;
await thirdTsc.Task;
await forthTcs.Task;
/* Assert */
Assert.NotNull(secondTcs.Task.Result);
Assert.True(true, "Received Response");
}
}
public async Task Should_Work_With_Generic_Messages()
{
using (var client = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions
{
Plugins = p => p
.UseStateMachine()
.UseMessageContext(context => new MessageContext {
GlobalRequestId = Guid.NewGuid()
})
.UseContextForwarding()
.UseGlobalExecutionId()
}))
{
/* Setup */
var guidMsg = new GenericMessage <Guid> {
Prop = Guid.NewGuid()
};
await client.SubscribeAsync <GenericMessage <string> >(message =>
client.PublishAsync(guidMsg)
);
/* Test */
var sequence = client.ExecuteSequence(s => s
.PublishAsync(new GenericMessage <string>())
.Complete <GenericMessage <Guid> >()
);
/* Assert */
Assert.Equal(sequence.Task.Result.Prop, guidMsg.Prop);
}
}
public async Task Should_Be_Able_To_Retry_Multiple_Times()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient(p => p.UseRetryLater()))
{
/* Setup */
var firstTsc = new TaskCompletionSource <DateTime>();
var secondTsc = new TaskCompletionSource <DateTime>();
var thirdTsc = new TaskCompletionSource <DateTime>();
await subscriber.SubscribeAsync <BasicMessage>(async received =>
{
var receivedAt = DateTime.Now;
if (firstTsc.TrySetResult(receivedAt))
{
return(Retry.In(TimeSpan.FromSeconds(1)));
}
if (secondTsc.TrySetResult(receivedAt))
{
return(Retry.In(TimeSpan.FromSeconds(1)));
}
thirdTsc.TrySetResult(receivedAt);
return(new Ack());
});
/* Test */
await publisher.PublishAsync(new BasicMessage { Prop = "Hello, world!" });
Task.WaitAll(firstTsc.Task, secondTsc.Task, thirdTsc.Task);
/* Assert */
Assert.Equal(1, (secondTsc.Task.Result - firstTsc.Task.Result).Seconds);
Assert.Equal(1, (thirdTsc.Task.Result - secondTsc.Task.Result).Seconds);
}
}
public async Task Should_Be_Able_To_Return_Nack_Without_Requeue()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var firstSubscriber = ZyRabbitFactory.CreateTestClient())
using (var secondSubscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var firstTsc = new TaskCompletionSource <BasicMessage>();
var secondTsc = new TaskCompletionSource <BasicMessage>();
await firstSubscriber.SubscribeAsync <BasicMessage>(async received =>
{
firstTsc.TrySetResult(received);
return(new Nack(requeue: false));
});
await secondSubscriber.SubscribeAsync <BasicMessage>(async received =>
{
secondTsc.TrySetResult(received);
return(new Nack(requeue: false));
});
var message = new BasicMessage {
Prop = "Hello, world!"
};
/* Test */
await publisher.PublishAsync(message);
Task.WaitAll(new [] { firstTsc.Task, secondTsc.Task }, TimeSpan.FromMilliseconds(200));
/* Assert */
Assert.Equal(message.Prop, firstTsc.Task.Result.Prop);
Assert.False(secondTsc.Task.IsCompleted);
}
}
public async Task Should_Be_Able_To_Perform_Multiple_Concurrent_Publishes()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var receivedCount = 0;
const int sendCount = 2000;
var publishTasks = new Task[sendCount];
var receivedTcs = new TaskCompletionSource <int>();
await subscriber.SubscribeAsync <BasicMessage>(received =>
{
Interlocked.Increment(ref receivedCount);
if (receivedCount == sendCount)
{
receivedTcs.TrySetResult(receivedCount);
}
return(Task.FromResult(true));
});
/* Test */
for (var i = 0; i < sendCount; i++)
{
publishTasks[i] = publisher.PublishAsync(new BasicMessage());
}
Task.WaitAll(publishTasks);
await receivedTcs.Task;
/* Assert */
Assert.Equal(receivedTcs.Task.Result, sendCount);
}
}
public async Task Should_Be_Able_To_Return_Reject_With_Requeue_From_Subscriber_With_Context()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var firstSubscriber = ZyRabbitFactory.CreateTestClient())
using (var secondSubscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var firstTsc = new TaskCompletionSource <BasicMessage>();
var secondTsc = new TaskCompletionSource <BasicMessage>();
await firstSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) =>
{
firstTsc.TrySetResult(received);
return(new Reject());
});
await secondSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) =>
{
secondTsc.TrySetResult(received);
return(new Ack());
});
var message = new BasicMessage {
Prop = "Hello, world!"
};
/* Test */
await publisher.PublishAsync(message);
Task.WaitAll(firstTsc.Task, secondTsc.Task);
/* Assert */
Assert.Equal(message.Prop, firstTsc.Task.Result.Prop);
Assert.Equal(message.Prop, secondTsc.Task.Result.Prop);
}
}
public async Task Should_Be_Able_To_Publish_With_Custom_Header()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var receivedTcs = new TaskCompletionSource <BasicDeliverEventArgs>();
await subscriber.SubscribeAsync <BasicMessage, BasicDeliverEventArgs>((received, args) =>
{
receivedTcs.TrySetResult(args);
return(Task.FromResult(true));
}, ctx => ctx.UseMessageContext(c => c.GetDeliveryEventArgs()));
var message = new BasicMessage {
Prop = "Hello, world!"
};
/* Test */
await publisher.PublishAsync(message, ctx => ctx
.UsePublishConfiguration(cfg => cfg
.WithProperties(props => props.Headers.Add("foo", "bar"))));
await receivedTcs.Task;
/* Assert */
Assert.True(receivedTcs.Task.Result.BasicProperties.Headers.ContainsKey("foo"));
}
}
public async Task Should_Honor_Exchange_Name_Configuration()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var receivedTcs = new TaskCompletionSource <BasicMessage>();
await subscriber.SubscribeAsync <BasicMessage>(received =>
{
receivedTcs.TrySetResult(received);
return(Task.FromResult(true));
}, ctx => ctx
.UseSubscribeConfiguration(cfg => cfg
.OnDeclaredExchange(e => e
.WithName("custom_exchange")
))
);
var message = new BasicMessage {
Prop = "Hello, world!"
};
/* Test */
await publisher.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange("custom_exchange")));
await receivedTcs.Task;
/* Assert */
Assert.Equal(message.Prop, receivedTcs.Task.Result.Prop);
}
}
public async Task Should_Not_Throw_Exception_When_Queue_Name_Is_Long()
{
using (var subscriber = ZyRabbitFactory.CreateTestClient())
using (var publisher = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var msgTcs = new TaskCompletionSource <BasicMessage>();
var message = new BasicMessage {
Prop = "I'm delivered to queue with truncated name"
};
var queueName = string.Empty;
while (queueName.Length < 254)
{
queueName = queueName + "this_is_part_of_a_long_queue_name";
}
await subscriber.SubscribeAsync <BasicMessage>(msg =>
{
msgTcs.TrySetResult(msg);
return(Task.FromResult(0));
}, ctx => ctx
.UseSubscribeConfiguration(cfg => cfg
.FromDeclaredQueue(q => q.WithName(queueName).WithAutoDelete())
)
);
/* Test */
await publisher.PublishAsync(message);
await msgTcs.Task;
/* Assert */
Assert.Equal(message.Prop, msgTcs.Task.Result.Prop);
}
}
public async Task Should_Consume_Message_Already_In_Queue()
{
using (var subscriber = ZyRabbitFactory.CreateTestClient())
using (var publisher = ZyRabbitFactory.CreateTestClient())
{
var msgTcs = new TaskCompletionSource <BasicMessage>();
var msg = new BasicMessage {
Prop = Guid.NewGuid().ToString()
};
await subscriber.DeclareQueueAsync <BasicMessage>();
await subscriber.DeclareExchangeAsync <BasicMessage>();
await subscriber.BindQueueAsync <BasicMessage>();
await publisher.PublishAsync(msg);
await subscriber.SubscribeAsync <BasicMessage>(message =>
{
msgTcs.TrySetResult(message);
return(Task.FromResult(true));
});
await msgTcs.Task;
Assert.Equal(msg.Prop, msgTcs.Task.Result.Prop);
}
}
public async Task Should_Work_Without_Any_Additional_Configuration()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var receivedTcs = new TaskCompletionSource <BasicMessage>();
await subscriber.SubscribeAsync <BasicMessage>(received =>
{
receivedTcs.TrySetResult(received);
return(Task.FromResult(true));
});
var message = new BasicMessage {
Prop = "Hello, world!"
};
/* Test */
await publisher.PublishAsync(message);
await receivedTcs.Task;
/* Assert */
Assert.Equal(message.Prop, receivedTcs.Task.Result.Prop);
}
}
public async Task Should_Be_Able_To_Create_Unique_Queue_With_Custom_Suffix()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var firstClient = ZyRabbitFactory.CreateTestClient())
using (var secondClient = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions
{
Plugins = p => p.UseCustomQueueSuffix("custom")
}))
{
/* Setup */
var firstTsc = new TaskCompletionSource <BasicMessage>();
var secondTsc = new TaskCompletionSource <BasicMessage>();
await firstClient.SubscribeAsync <BasicMessage>(message =>
{
firstTsc.TrySetResult(message);
return(Task.FromResult(0));
});
await secondClient.SubscribeAsync <BasicMessage>(message =>
{
secondTsc.TrySetResult(message);
return(Task.FromResult(0));
});
/* Test */
await publisher.PublishAsync(new BasicMessage());
await firstTsc.Task;
await secondTsc.Task;
/* Assert */
Assert.True(true, "Should be delivered to both subscribers");
}
}
public async Task Should_Not_Use_Timeout_If_Cancellation_Token_Is_Provided()
{
using (var requester = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var timeout = TimeSpan.FromMilliseconds(300);
var timeoutCs = new CancellationTokenSource();
/* Test */
/* Assert */
var requestTask = requester.RequestAsync <BasicRequest, BasicResponse>(
message: new BasicRequest(),
context: ctx => ctx.UseRequestTimeout(timeout),
ct: timeoutCs.Token
);
await Task.Delay(timeout.Add(TimeSpan.FromMilliseconds(100)));
Assert.False(requestTask.IsFaulted);
Assert.False(requestTask.IsCanceled);
Assert.False(requestTask.IsCompleted);
timeoutCs.Cancel();
await Task.Delay(timeout.Add(TimeSpan.FromMilliseconds(50)));
Assert.True(requestTask.IsCanceled);
}
}
public async Task Should_Work_For_Subscribe()
{
using (var subscriber = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions {
Plugins = plugin => plugin.UseAttributeRouting()
}))
using (var publisher = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var receivedTcs = new TaskCompletionSource <AttributedMessage>();
await subscriber.SubscribeAsync <AttributedMessage>(received =>
{
receivedTcs.TrySetResult(received);
return(Task.FromResult(true));
});
/* Test */
await publisher.PublishAsync(new AttributedMessage(), ctx => ctx
.UsePublishConfiguration(cfg => cfg
.OnDeclaredExchange(e => e
.WithName("my_topic")
.WithType(ExchangeType.Topic))
.WithRoutingKey("my_key")
));
await receivedTcs.Task;
/* Assert */
Assert.True(true, "Routing successful");
}
}
public static async Task Main()
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
_client = ZyRabbitFactory.CreateSingleton(new ZyRabbitOptions
{
ClientConfiguration = new ConfigurationBuilder()
.AddJsonFile("zyrabbit.json")
.Build()
.Get <ZyRabbitConfiguration>(),
Plugins = p => p
.UseGlobalExecutionId()
.UseMessageContext <MessageContext>(),
DependencyInjection = register =>
{
register.AddSingleton(typeof(ILogger <>), typeof(SerilogLogger <>));
register.AddSingleton <Microsoft.Extensions.Logging.ILogger, SerilogLogger <object> >(resolver => new SerilogLogger <object>());
}
});
await _client.SubscribeAsync <ValuesRequested, MessageContext>((requested, ctx) => ServerValuesAsync(requested, ctx));
await _client.RespondAsync <ValueRequest, ValueResponse>(request => SendValuesThoughRpcAsync(request));
Console.ReadKey();
}
public async Task Should_Work_For_Request()
{
using (var requester = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions
{
Plugins = plugin => plugin.UseAttributeRouting()
}
))
using (var responder = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var receivedTcs = new TaskCompletionSource <AttributedRequest>();
await responder.RespondAsync <AttributedRequest, AttributedResponse>(received =>
{
receivedTcs.TrySetResult(received);
return(Task.FromResult(new AttributedResponse()));
}, ctx => ctx.UseRespondConfiguration(cfg => cfg
.Consume(c => c
.WithRoutingKey("my_request_key"))
.OnDeclaredExchange(e => e
.WithName("rpc_exchange")
.WithType(ExchangeType.Topic))
));
/* Test */
await requester.RequestAsync <AttributedRequest, AttributedResponse>(new AttributedRequest());
await receivedTcs.Task;
/* Assert */
Assert.True(true, "Routing successful");
}
}
public async Task Should_Be_Able_To_Ack_Messages_And_Then_Full_List()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null);
TestChannel.ExchangeDeclare(conventions.ExchangeNamingConvention(message.GetType()), ExchangeType.Topic);
TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), exchangeName, conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackable = await client.GetManyAsync <BasicMessage>(3);
ackable.Content[1].Ack();
ackable.Ack();
TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType()));
TestChannel.ExchangeDelete(exchangeName);
/* Assert */
Assert.True(true);
}
}
public async Task Should_Honor_Task_Cancellation()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = Guid.NewGuid().ToString()
};
var receivedTcs = new TaskCompletionSource <BasicMessage>();
var sendCts = new CancellationTokenSource();
await subscriber.SubscribeAsync <BasicMessage>(received =>
{
if (received.Prop == message.Prop)
{
receivedTcs.TrySetResult(received);
}
return(Task.FromResult(true));
});
/* Test */
sendCts.CancelAfter(TimeSpan.FromTicks(400));
var publishTask = publisher.PublishAsync(new BasicMessage(), token: sendCts.Token);
receivedTcs.Task.Wait(100);
/* Assert */
Assert.False(receivedTcs.Task.IsCompleted, "Message was sent, even though execution was cancelled.");
Assert.True(publishTask.IsCanceled, "The publish task should be cancelled.");
}
}
public async Task Should_Be_Able_To_Get_Message_When_Batch_Size_Is_Smaller_Than_Queue_Length()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
TestChannel.QueueDeclare(conventions.QueueNamingConvention(message.GetType()), true, false, false, null);
TestChannel.ExchangeDeclare(conventions.ExchangeNamingConvention(message.GetType()), ExchangeType.Topic);
TestChannel.QueueBind(conventions.QueueNamingConvention(message.GetType()), conventions.ExchangeNamingConvention(message.GetType()), conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackable = await client.GetManyAsync <BasicMessage>(2);
TestChannel.QueueDelete(conventions.QueueNamingConvention(message.GetType()));
TestChannel.ExchangeDelete(exchangeName);
/* Assert */
Assert.NotNull(ackable);
Assert.Equal(ackable.Content.Count, 2);
}
}
public async Task Should_Be_Able_To_Return_Retry_From_Subscriber_With_Context()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var firstSubscriber = ZyRabbitFactory.CreateTestClient(p => p.UseRetryLater()))
using (var secondSubscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var firstTsc = new TaskCompletionSource <DateTime>();
var secondTsc = new TaskCompletionSource <DateTime>();
await firstSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) =>
{
firstTsc.TrySetResult(DateTime.Now);
return(Retry.In(TimeSpan.FromSeconds(1)));
});
await secondSubscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) =>
{
secondTsc.TrySetResult(DateTime.Now);
return(new Ack());
});
var message = new BasicMessage {
Prop = "Hello, world!"
};
/* Test */
await publisher.PublishAsync(message);
Task.WaitAll(firstTsc.Task, secondTsc.Task);
/* Assert */
Assert.Equal(1, (secondTsc.Task.Result - firstTsc.Task.Result).Seconds);
}
}
public async Task Should_Not_Invoke_Mandatory_Callback_If_Message_Is_Undelivered()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var deliveredTcs = new TaskCompletionSource <BasicMessage>();
var callbackTcs = new TaskCompletionSource <BasicReturnEventArgs>();
await subscriber.SubscribeAsync <BasicMessage>(message =>
{
deliveredTcs.TrySetResult(message);
return(Task.FromResult(0));
});
/* Test */
await publisher.PublishAsync(new BasicMessage { Prop = "Hello, world!" }, ctx => ctx
.UsePublishConfiguration(cfg => cfg
.WithReturnCallback(args =>
{
callbackTcs.TrySetResult(args);
})
));
await deliveredTcs.Task;
callbackTcs.Task.Wait(TimeSpan.FromMilliseconds(200));
/* Assert */
Assert.False(callbackTcs.Task.IsCompleted);
}
}
public async Task Should_Be_Able_To_Return_Ack_From_Subscriber_With_Context()
{
using (var publisher = ZyRabbitFactory.CreateTestClient())
using (var subscriber = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var receivedTcs = new TaskCompletionSource <BasicMessage>();
await subscriber.SubscribeAsync <BasicMessage, MessageContext>(async (received, context) =>
{
receivedTcs.TrySetResult(received);
return(new Ack());
});
var message = new BasicMessage {
Prop = "Hello, world!"
};
/* Test */
await publisher.PublishAsync(message);
await receivedTcs.Task;
/* Assert */
Assert.Equal(message.Prop, receivedTcs.Task.Result.Prop);
}
}
public async Task Should_Deliver_And_Reiieve_Messages_Serialized_With_Protobuf()
{
using (var client = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions {
Plugins = p => p.UseProtobuf()
}))
{
/** Setup **/
var tcs = new TaskCompletionSource <ProtoMessage>();
var message = new ProtoMessage
{
Member = "Straight into bytes",
Id = Guid.NewGuid()
};
await client.SubscribeAsync <ProtoMessage>(msg =>
{
tcs.TrySetResult(msg);
return(Task.CompletedTask);
});
/** Test **/
await client.PublishAsync(message);
await tcs.Task;
/** Assert **/
Assert.Equal(tcs.Task.Result.Id, message.Id);
Assert.Equal(tcs.Task.Result.Member, message.Member);
}
}
public async Task Should_Publish_And_Subscribe_with_Zero_Formatter()
{
using (var client = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions {
Plugins = p => p.UseMessagePack()
}))
{
/** Setup **/
var tcs = new TaskCompletionSource <MessagePackMessage>();
var message = new MessagePackMessage
{
TagLine = "Extremely Fast MessagePack Serializer for C#"
};
await client.SubscribeAsync <MessagePackMessage>(msg =>
{
tcs.TrySetResult(msg);
return(Task.CompletedTask);
});
/** Test **/
await client.PublishAsync(message);
await tcs.Task;
/** Assert **/
Assert.Equal(tcs.Task.Result.TagLine, message.TagLine);
}
}
public async Task Should_Work_For_Full_Rpc()
{
using (var responder = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions {
Plugins = plugin => plugin.UseAttributeRouting()
}))
using (var requester = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions {
Plugins = plugin => plugin.UseAttributeRouting()
}))
{
/* Setup */
var receivedTcs = new TaskCompletionSource <AttributedRequest>();
await responder.RespondAsync <AttributedRequest, AttributedResponse>(received =>
{
receivedTcs.TrySetResult(received);
return(Task.FromResult(new AttributedResponse()));
});
/* Test */
await requester.RequestAsync <AttributedRequest, AttributedResponse>(new AttributedRequest());
await receivedTcs.Task;
/* Assert */
Assert.True(true, "Routing successful");
}
}
public async Task Should_Create_Simple_Chain_Of_One_Send_And_Final_Receive()
{
/* Setup */
using (var client = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions
{
Plugins = p => p
.UseGlobalExecutionId()
.UseStateMachine()
}))
{
await client.SubscribeAsync <BasicRequest, MessageContext>((request, context) =>
client.PublishAsync(new BasicResponse())
);
/* Test */
var chain = client.ExecuteSequence(c => c
.PublishAsync <BasicRequest>()
.Complete <BasicResponse>()
);
await chain.Task;
/* Assert */
Assert.True(true, "Received Response");
}
}
public async Task Should_Work_For_Pub_Sub()
{
using (var publisher = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions {
Plugins = plugin => plugin.UseAttributeRouting()
}))
using (var subscriber = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions {
Plugins = plugin => plugin.UseAttributeRouting()
}))
{
/* Setup */
var receivedTcs = new TaskCompletionSource <AttributedMessage>();
await subscriber.SubscribeAsync <AttributedMessage>(received =>
{
receivedTcs.TrySetResult(received);
return(Task.FromResult(new AttributedResponse()));
});
/* Test */
await publisher.PublishAsync(new AttributedMessage());
await receivedTcs.Task;
/* Assert */
Assert.True(true, "Routing successful");
}
}
public async Task Should_Abort_Execution_If_Configured_To()
{
/* Setup */
using (var client = ZyRabbitFactory.CreateTestClient(new ZyRabbitOptions
{
Plugins = p => p
.UseStateMachine()
.UseGlobalExecutionId()
}))
{
var secondTcs = new TaskCompletionSource <SecondMessage>();
await client.SubscribeAsync <FirstMessage, MessageContext>((request, context) =>
client.PublishAsync(new SecondMessage())
);
/* Test */
var chain = client.ExecuteSequence(c => c
.PublishAsync <FirstMessage>()
.When <SecondMessage, MessageContext>((message, context) =>
{
secondTcs.TrySetResult(message);
return(Task.FromResult(0));
}, it => it.AbortsExecution())
.Complete <ThirdMessage>()
);
await chain.Task;
await secondTcs.Task;
/* Assert */
Assert.NotNull(secondTcs.Task.Result);
Assert.True(chain.Aborted);
}
}
public async Task Should_Be_Able_To_Get_BasicGetResult_Message()
{
using (var client = ZyRabbitFactory.CreateTestClient())
{
/* Setup */
var message = new BasicMessage {
Prop = "Get me, get it?"
};
var conventions = new NamingConventions();
var exchangeName = conventions.ExchangeNamingConvention(message.GetType());
var queueName = conventions.QueueNamingConvention(message.GetType());
TestChannel.QueueDeclare(queueName, true, false, false, null);
TestChannel.ExchangeDeclare(exchangeName, ExchangeType.Topic);
TestChannel.QueueBind(queueName, exchangeName, conventions.RoutingKeyConvention(message.GetType()) + ".#");
await client.PublishAsync(message, ctx => ctx.UsePublishConfiguration(cfg => cfg.OnExchange(exchangeName)));
/* Test */
var ackable = await client.GetAsync(cfg => cfg.FromQueue(queueName));
/* Assert */
Assert.NotNull(ackable);
Assert.NotEmpty(ackable.Content.Body);
TestChannel.QueueDelete(queueName);
TestChannel.ExchangeDelete(exchangeName);
}
}
