public async Task SendJsonBodyMessage()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var serializer = new JsonObjectSerializer();
var testBody = new TestBody
{
A = "text",
B = 5,
C = false
};
var body = BinaryData.Create(testBody, serializer);
var msg = new ServiceBusMessage(body);
await sender.SendAsync(msg);
var receiver = client.CreateReceiver(scope.QueueName);
var received = await receiver.ReceiveAsync();
var receivedBody = received.Body.As <TestBody>(serializer);
Assert.AreEqual(testBody.A, receivedBody.A);
Assert.AreEqual(testBody.B, receivedBody.B);
Assert.AreEqual(testBody.C, receivedBody.C);
}
}
public void CanCreateBinaryDataFromString()
{
var payload = "some data";
var data = BinaryData.Create(payload);
Assert.AreEqual(payload, data.AsString());
}
public void AsStringThrowsOnNullEncoding()
{
var payload = "some data";
var data = BinaryData.Create(payload);
Assert.That(
() => data.AsString(null),
Throws.InstanceOf <ArgumentException>());
}
public void MaxStreamLengthRespected()
{
var mockStream = new Mock <Stream>();
mockStream.Setup(s => s.CanSeek).Returns(true);
mockStream.Setup(s => s.Length).Returns((long)int.MaxValue + 1);
Assert.That(
() => BinaryData.Create(mockStream.Object),
Throws.InstanceOf <ArgumentOutOfRangeException>());
}
public void CreateThrowsOnNullStream()
{
Assert.That(
() => BinaryData.Create(stream: null),
Throws.InstanceOf <ArgumentNullException>());
Assert.That(
async() => await BinaryData.CreateAsync(stream: null),
Throws.InstanceOf <ArgumentNullException>());
}
public void CanCreateBinaryDataFromString()
{
var payload = "some data";
var data = BinaryData.Create(payload);
Assert.AreEqual(payload, data.AsString());
// using implicit conversion to string
string stringData = data;
Assert.AreEqual(payload, stringData);
}
public void GenericCreateThrowsOnNullSerializer()
{
var payload = new TestModel {
A = "value", B = 5, C = true
};
Assert.That(
() => BinaryData.Create(payload, null),
Throws.InstanceOf <ArgumentNullException>());
Assert.That(
async() => await BinaryData.CreateAsync(payload, null),
Throws.InstanceOf <ArgumentNullException>());
}
public async Task CanCreateBinaryDataFromStream()
{
var buffer = Encoding.UTF8.GetBytes("some data");
var payload = new MemoryStream(buffer);
var data = BinaryData.Create(payload);
Assert.AreEqual(buffer, data.AsBytes().ToArray());
Assert.AreEqual(payload, data.AsStream());
payload.Position = 0;
data = await BinaryData.CreateAsync(payload);
Assert.AreEqual(buffer, data.AsBytes().ToArray());
Assert.AreEqual(payload, data.AsStream());
}
public void AsThrowsOnNullSerializer()
{
var payload = new TestModel {
A = "value", B = 5, C = true
};
var serializer = new JsonObjectSerializer();
var data = BinaryData.Create(payload, serializer);
Assert.That(
() => data.As <TestModel>(null),
Throws.InstanceOf <ArgumentNullException>());
Assert.That(
async() => await data.AsAsync <TestModel>(null),
Throws.InstanceOf <ArgumentNullException>());
}
public async Task CanCreateBinaryDataFromCustomType()
{
var payload = new TestModel {
A = "value", B = 5, C = true
};
var serializer = new JsonObjectSerializer();
await AssertData(BinaryData.Create(payload, serializer));
await AssertData(await BinaryData.CreateAsync(payload, serializer));
async Task AssertData(BinaryData data)
{
Assert.AreEqual(payload.A, data.As <TestModel>(serializer).A);
Assert.AreEqual(payload.B, data.As <TestModel>(serializer).B);
Assert.AreEqual(payload.C, data.As <TestModel>(serializer).C);
Assert.AreEqual(payload.A, (await data.AsAsync <TestModel>(serializer)).A);
Assert.AreEqual(payload.B, (await data.AsAsync <TestModel>(serializer)).B);
Assert.AreEqual(payload.C, (await data.AsAsync <TestModel>(serializer)).C);
}
}
public async Task AsThrowsExceptionOnIncompatibleType()
{
var payload = new TestModel {
A = "value", B = 5, C = true
};
var serializer = new JsonObjectSerializer();
AssertData(BinaryData.Create(payload, serializer));
AssertData(await BinaryData.CreateAsync(payload, serializer));
void AssertData(BinaryData data)
{
Assert.That(
() => data.As <string>(serializer),
Throws.InstanceOf <Exception>());
Assert.That(
async() => await data.AsAsync <string>(serializer),
Throws.InstanceOf <Exception>());
}
}
/// <summary>
/// Creates a new message from the specified string, using the specified encoding.
/// </summary>
/// <param name="body">The payload of the message as a string.</param>
/// <param name="encoding">The encoding to use for the body.</param>
public ServiceBusMessage(string body, Encoding encoding)
{
Argument.AssertNotNull(encoding, nameof(encoding));
Body = BinaryData.Create(body, encoding);
Properties = new Dictionary <string, object>();
}
