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_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);
}
}
private void buttonSendLog_Click(object sender, EventArgs e)
{
byte[] buffer = new byte[350000];
BasicMessage message = new BasicMessage(buffer);
this.client.SendAsync(message);
}
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_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 bool Process(BasicMessage message)
{
Console.WriteLine(message.Body);
// return true if you want to ack immediately. False if you want to handle the ack (e.g. dispatch to a thread - and ack later).
return(true);
}
public void TryReadMessageTestOneLongMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[SocketStateObject.BufferSize * 2];
AbstractMessage messageToWrite = new BasicMessage(Guid.NewGuid(), fakeBody);
// Prepare the received buffer
SocketStateObject state = new SocketStateObject();
int offset = messageToWrite.Header.Write(state.buffer, 0);
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = SocketStateObject.BufferSize;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
byteRead = SocketStateObject.BufferSize;
actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
byteRead = messageToWrite.Header.HeaderLength;
actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
private void Send(ClientInfo client, ContainerMessage message)
{
try
{
string mc = message.Content;
if (mc.Length > 20)
{
mc = mc.Substring(0, 20) + "...";
}
RaiseNewTextEvent(string.Format("Sending message [{0} -> {1}: {2} # {3}]", message.Sender, message.Receiver, message.Info, mc));
string s = ContainerMessage.Serialize(message);
byte[] buffer = ASCIIEncoding.Unicode.GetBytes(s);
BasicMessage m = new BasicMessage(_serverGuid, buffer);
client.TcpSocketClientHandler.SendAsync(m);
}
catch (SocketException se)
{
// "An existing connection was forcibly closed by the remote host"
RaiseNewTextEvent("Container " + _containerNames[client] + " is disconnected.");
_containerNames.Remove(client);
client.TcpSocketClientHandler.Close();
RaiseNewTextEvent("Exception in Server.Send: " + se.Message + ".");
}
catch (Exception ex)
{
RaiseNewTextEvent("Exception in Server.Send: " + ex.Message + ".");
}
}
private void NextMessage(BasicMessage message)
{
foreach (var item in observers)
{
item.OnNext(message);
}
}
public async Task OnPostSendMessageAsync(string connectionId, string text)
{
var context = new DefaultAgentContext
{
Wallet = await _walletService.GetWalletAsync(_walletOptions.WalletConfiguration, _walletOptions.WalletCredentials)
};
var sentTime = DateTime.UtcNow;
var messageRecord = new BasicMessageRecord
{
Id = Guid.NewGuid().ToString(),
Direction = MessageDirection.Outgoing,
Text = text,
SentTime = sentTime,
ConnectionId = connectionId
};
var message = new BasicMessage
{
Content = text,
SentTime = sentTime.ToString("s", CultureInfo.InvariantCulture)
};
var connection = await _connectionService.GetAsync(context, connectionId);
// Save the outgoing message to the local wallet for chat history purposes
await _recordService.AddAsync(context.Wallet, messageRecord);
// Send an agent message using the secure connection
await _messageService.SendAsync(context.Wallet, message, connection);
}
/// <summary>
/// Quickly and easily send a basic message without the need to build up a message object
/// or instantiate a SocketLabsClient.
/// </summary>
/// <param name="serverId">Your SocketLabs ServerId number.</param>
/// <param name="apiKey">Your SocketLabs Injection API key.</param>
/// <param name="toAddress">The To address for your message recipient.</param>
/// <param name="fromAddress">The From address to be used for your message.</param>
/// <param name="subject">The subject for your message.</param>
/// <param name="htmlContent">The Html content for your message.</param>
/// <param name="textContent">The plain text content for your message.</param>
/// <remarks>The message must contain either htmlContent, textContent, or both to be valid.</remarks>
/// <returns>A <c>SendResponse</c> of an SocketLabsClient send request.</returns>
/// <example>
/// This sample shows you how to send a message using QuickSend
/// <code>
/// var response = SocketLabsClient.QuickSend(000000, "apiKey",
/// "*****@*****.**",
/// "*****@*****.**",
/// "Lorem Ipsum",
/// "<html>Lorem Ipsum</html>",
/// "Lorem Ipsum"
/// );
/// </code>
/// </example>
public static SendResponse QuickSend(
int serverId,
string apiKey,
string toAddress,
string fromAddress,
string subject,
string htmlContent,
string textContent)
{
var client = new SocketLabsClient(serverId, apiKey);
var email = new BasicMessage
{
Subject = subject,
To =
{
new EmailAddress(toAddress)
},
From = new EmailAddress(fromAddress),
HtmlBody = htmlContent,
PlainTextBody = textContent
};
return(client.Send(email));
}
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_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_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 SendResponse RunExample()
{
var client = new SocketLabsClient(ExampleConfig.ServerId, ExampleConfig.ApiKey);
var message = new BasicMessage();
message.To.Add("*****@*****.**");
message.To.Add("*****@*****.**", "Recipient #2");
message.Subject = "Sending Basic Complex Example";
message.HtmlBody = "<body><p><strong>Lorem Ipsum</strong></p><br /><img src=\"cid:Bus\" /></body>";
message.PlainTextBody = "Lorem Ipsum";
message.CharSet = "utf-8";
message.From.Email = "*****@*****.**";
message.ReplyTo.Email = "*****@*****.**";
message.MailingId = "MyMailingId";
message.MessageId = "MyMsgId";
message.CustomHeaders.Add("x-mycustomheader", "I am a message header");
var attachment = message.Attachments.Add("bus.png", MimeType.PNG, @".\examples\img\bus.png");
attachment.ContentId = "Bus";
return(client.Send(message));
}
public void InequalByOthersNullArgs()
{
var msg = new BasicMessage("test", 1);
var msg2 = new BasicMessage("test", null);
Assert.False(msg.Equals(msg2));
}
private void UnselectObject(BasicMessage m = null)
{
_gizmo.Clear();
_selectedObject.Select(false);
_editionSceneObject.Reset();
Messenger.Notify(EditorEvent.SceneObjectUnSelected);
}
public void InequalByType()
{
var msg = new BasicMessage("test", 1);
var msg2 = new BasicMessage("tot", 1);
Assert.False(msg.Equals(msg2));
}
public async Task Invoke(BasicMessage basicMessage)
{
using var scope = scopeFactory.CreateScope();
var middlewares = LoadMiddlewares(scope);
var middlewareInvoker = new MiddlewareInvoker(middlewares);
await middlewareInvoker.Invoke(new MiddlewareContext(basicMessage));
}
public void InequalByParameterAmount()
{
var msg = new BasicMessage("test", 1);
var msg2 = new BasicMessage("test", 1, 2);
Assert.False(msg.Equals(msg2));
}
public void TryReadMessageTestTwoCompleteMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[10];
AbstractMessage messageToWrite1 = new BasicMessage(Guid.NewGuid(), fakeBody);
// Prepare the received buffer
SocketStateObject state = new SocketStateObject();
int offset = messageToWrite1.Header.Write(state.buffer, 0);
offset += fakeBody.Length;
fakeBody = new byte[15];
AbstractMessage messageToWrite2 = new BasicMessage(Guid.NewGuid(), fakeBody);
offset = messageToWrite2.Header.Write(state.buffer, offset);
offset += fakeBody.Length;
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = offset;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite1.MessageLength);
Assert.IsNull(state.message);
Assert.IsNotNull(state.pendingBuffer);
actual = AbstractMessage.TryReadMessage(message, state, 0);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite2.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
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_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_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_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);
}
}
/// <summary>
/// 按钮点击事件-查询出入信息
/// </summary>
/// <param name="sender">事件源</param>
/// <param name="e">事件参数</param>
private void QueryBtn_Click(object sender, RoutedEventArgs e)
{
if (!string.IsNullOrEmpty(moldNR))
{
ConditionServiceClient conditionclient = new ConditionServiceClient();
BasicMessage msg = new BasicMessage();
if (!conditionclient.MoldExist(moldNR))
{
msg.Result = false;
msg.MsgContent.Add("模具");
}
if (applicantNRTB.Text.Length != 0 && !conditionclient.EmpExist(applicantNRTB.Text))
{
msg.Result = false;
msg.MsgContent.Add("员工");
}
if (msg.Result == false)
{
MessageBox.Show(msg.MsgText + " 不存在，请重新输入");
return;
}
MoldPartInfoServiceClient client = new MoldPartInfoServiceClient();
DateTime?startDT = null;
DateTime?endDT = null;
startDT = startDateDP.Text.Length == 0 ? startDT : DateTime.Parse(startDateDP.Text);
endDT = endDateDP.Text.Length == 0 ? endDT : DateTime.Parse(endDateDP.Text);
List <StorageRecord> storageRecord = client.GetMoldApplyRecords(moldNR, applicantNRTB.Text, startDT, endDT);
MoldInOutInfoDG.ItemsSource = storageRecord;
}
}
public SendResponse RunExample()
{
var message = new BasicMessage();
message.Subject = "Sending A Test Message";
message.HtmlBody = "<html>This is the Html Body of my message.</html>";
message.PlainTextBody = "This is the Plain Text Body of my message.";
message.From.Email = "*****@*****.**";
message.ReplyTo.Email = "*****@*****.**";
message.To.Add("!@#$!@#$!@#$@#!$");
message.To.Add("failure.com");
message.To.Add("ImMissingSomething");
message.To.Add("Fail@@!.Me");
message.To.Add("this@works");
message.To.Add("*****@*****.**");
using (var client = new SocketLabsClient(ExampleConfig.ServerId, ExampleConfig.ApiKey)
{
EndpointUrl = ExampleConfig.TargetApi
})
{
try
{
var response = client.Send(message);
return(response);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public void AddDifferentFilteredMessages()
{
IFilteredMessageReceiver receiver = new FilteredMessageReceiver();
receiver.ChangeMessageFilter(typeof(IErrorMessage));
receiver.ChangeErrorFilter(2);
var s = "This is a message";
var t = "And another...";
var b = "...blah...";
var u = "...and another...";
IMessage basic0 = new BasicMessage(s);
IMessage basic1 = new ErrorMessage(t, 2);
IMessage basic2 = new BasicMessage(u);
IMessage basic3 = new ErrorMessage(b, 1);
var temp = new List <IMessage>();
temp.Add(basic0);
temp.Add(basic1);
temp.Add(basic2);
temp.Add(basic3);
receiver.ReceiveAll(temp);
var filteredMessages = receiver.GetAllMessages();
Assert.AreEqual(1, receiver.GetAllMessages().Count);
Assert.AreNotEqual(s, receiver.GetAllMessages()[0].GetMessage());
Assert.AreEqual(t, receiver.GetAllMessages()[0].GetMessage());
Assert.AreNotEqual(b, receiver.GetAllMessages()[0].GetMessage());
Assert.AreEqual(2, ((ErrorMessage)receiver.GetAllMessages()[0]).GetErrorLevel());
Assert.AreNotEqual(u, receiver.GetAllMessages()[0].GetMessage());
}
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 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);
}
}
