public Task ScheduleQueueMessageAsync <T>(JsonSerializedMessage <T> message, DateTimeOffset scheduleEnqueueTimeUtc) where T : new()
{
return(ScheduleQueueMessagesAsync(new JsonSerializedMessage <T>[1]
{
message
}, scheduleEnqueueTimeUtc));
}
public async Task ShouldSerializeAndSend_InCamelCase(
[Frozen] Mock <IMessageTypeCache> cache,
[Frozen] Mock <IConnection> connection,
string typeId,
MyMessage message,
JsonConnection sut)
{
cache.Setup(x => x.GetTypeId(typeof(MyMessage)))
.Returns(typeId);
JsonSerializedMessage sent = null !;
connection.Setup(x => x.SendAsync(It.IsAny <object>(), Cts.Token))
.Callback <object, CancellationToken>((message, ct) => sent = (JsonSerializedMessage)message);
await sut.SendAsync(message, Cts.Token);
Assert.Equal(typeId, sent.TypeId);
Assert.Equal(
JsonSerializer.Serialize(
message,
new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
}),
sent.Json);
}
public Task SendTopicMessageAsync <T>(JsonSerializedMessage <T> message) where T : new()
{
return(SendTopicMessagesAsync(new JsonSerializedMessage <T>[1]
{
message
}));
}
public bool InvokingJsonService()
{
string name = Guid.NewGuid().ToString();
var message = new JsonSerializedMessage()
{
Name = name
};
var httpResponse = _navigation.GetEndpointDriver().PostJson(message);
var response = httpResponse.ReadAsJson <JsonSerializedMessage>();
return(response.Name == name);
}
public bool InvokingJsonService()
{
string name = Guid.NewGuid().ToString();
var message = new JsonSerializedMessage()
{
Name = name
};
var response =
_application.InvokeJson <JsonSerializedMessage>("http://localhost/fubu-testing/testpackage1/json/sendmessage", message);
return(response.Name == name);
}
public async Task ShouldThrow_WhenDeserializationReturnsNull(
[Frozen] Mock <IMessageTypeCache> cache,
[Frozen] Mock <IConnection> connection,
JsonSerializedMessage jsonMessage,
JsonConnection sut)
{
jsonMessage.Json = "null";
connection.Setup(x => x.ReceiveAsync(Cts.Token))
.ReturnsAsync(jsonMessage);
cache.Setup(x => x.GetTypeById(jsonMessage.TypeId))
.Returns(typeof(MyMessage));
await Assert.ThrowsAsync <InvalidOperationException>(
async() => await sut.ReceiveAsync(Cts.Token));
}
public async Task ShouldDeserializeEnum_FromNumber(
[Frozen] Mock <IMessageTypeCache> cache,
[Frozen] Mock <IConnection> connection,
JsonSerializedMessage jsonMessage,
JsonConnection sut)
{
jsonMessage.Json = "{\"testEnum\":2}";
connection.Setup(x => x.ReceiveAsync(Cts.Token))
.ReturnsAsync(jsonMessage);
cache.Setup(x => x.GetTypeById(jsonMessage.TypeId))
.Returns(typeof(TestEnumMessage));
var result = (TestEnumMessage)await sut.ReceiveAsync(Cts.Token);
Assert.Equal(TestEnum.Two, result.TestEnum);
}
public void JsonSerializedMessage()
{
AssertSerializable <JsonSerializedMessage>();
var sut = new JsonSerializedMessage("typeId", "json");
Assert.Equal("typeId", sut.TypeId);
Assert.Equal("json", sut.Json);
sut = new JsonSerializedMessage
{
TypeId = "typeId",
Json = "json"
};
Assert.Equal("typeId", sut.TypeId);
Assert.Equal("json", sut.Json);
}
public async Task ShouldSerializeEnum_ToString(
[Frozen] Mock <IMessageTypeCache> cache,
[Frozen] Mock <IConnection> connection,
string typeId,
JsonConnection sut)
{
cache.Setup(x => x.GetTypeId(typeof(TestEnumMessage)))
.Returns(typeId);
JsonSerializedMessage sent = null !;
connection.Setup(x => x.SendAsync(It.IsAny <object>(), Cts.Token))
.Callback <object, CancellationToken>((message, ct) => sent = (JsonSerializedMessage)message);
await sut.SendAsync(new TestEnumMessage { TestEnum = TestEnum.Two }, Cts.Token);
Assert.Equal(typeId, sent.TypeId);
Assert.Equal("{\"testEnum\":\"Two\"}", sent.Json);
}
public async Task ShouldReceiveAndDeserialize_InCamelCase(
[Frozen] Mock <IMessageTypeCache> cache,
[Frozen] Mock <IConnection> connection,
MyMessage message,
JsonSerializedMessage jsonMessage,
JsonConnection sut)
{
jsonMessage.Json = JsonSerializer.Serialize(message, new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
connection.Setup(x => x.ReceiveAsync(Cts.Token))
.ReturnsAsync(jsonMessage);
cache.Setup(x => x.GetTypeById(jsonMessage.TypeId))
.Returns(typeof(MyMessage));
var result = (MyMessage)await sut.ReceiveAsync(Cts.Token);
Assert.Equal(message.Age, result.Age);
Assert.Equal(message.LastName, result.LastName);
Assert.Equal(message.List, result.List);
}
public async Task SendMessagesAsync <T>(
IList <T> messages,
string subject = "",
CancellationToken cancellationToken = default)
{
var messageTypes = messages.Select(m => m?.GetType()).Distinct();
EnsureMessagesAreMapped(messageTypes);
var queuedMessages = new Queue <ServiceBusMessage>();
var producerInfo = _mappings[Named].Find(x => x.MessageType == typeof(T));
foreach (var message in messages)
{
var queuedMessage = new JsonSerializedMessage <T>(message);
if (!string.IsNullOrEmpty(producerInfo?.Subscription))
{
queuedMessage.Subject = producerInfo.Subscription;
}
if (!string.IsNullOrEmpty(subject))
{
queuedMessage.Subject = subject;
}
queuedMessages.Enqueue(queuedMessage);
}
var client = _connection.CreateClient(Named);
var sender = client.CreateSender(producerInfo.QueueOrTopicName);
// create a message batch that we can send
// total number of messages to be sent to the Service Bus queue
var messageCount = messages.Count;
// while all messages are not sent to the Service Bus queue
while (queuedMessages.Count > 0)
{
// start a new batch
using var messageBatch = await sender.CreateMessageBatchAsync(cancellationToken);
// add the first message to the batch
if (messageBatch.TryAddMessage(queuedMessages.Peek()))
{
// dequeue the message from the .NET queue once the message is added to the batch
queuedMessages.Dequeue();
}
else
{
// if the first message can't fit, then it is too large for the batch
throw new Exception($"Message {messageCount - messages.Count} is too large and cannot be sent.");
}
// add as many messages as possible to the current batch
while (queuedMessages.Count > 0 && messageBatch.TryAddMessage(queuedMessages.Peek()))
{
// dequeue the message from the .NET queue as it has been added to the batch
queuedMessages.Dequeue();
}
// now, send the batch
await sender.SendMessagesAsync(messageBatch, cancellationToken);
// if there are any remaining messages in the .NET queue, the while loop repeats
}
}
public void Send(JsonSerializedMessage message)
{
_server.NotifyReceived(Context.ConnectionId, message);
}
