public void Create_NullInputType_ThrowsException()
{
var exception = Assert.Throws <ArgumentNullException>(() =>
MessagePackContent.Create(new object(), null,
MessagePackSerializerOptions.Standard, MessagePackDefaults.MediaTypeHeader));
Assert.Equal("inputType", exception.ParamName);
}
public async Task ReadFromMessagePackAsync_Generic_NullObject_Test()
{
var content = MessagePackContent.Create <SimpleType>(null, _options);
var model = await content.ReadFromMessagePackAsync <SimpleType>(_options);
Assert.Null(model);
}
public async Task ReadFromMessagePackAsync_Generic_Test()
{
var content = MessagePackContent.Create(SimpleType.Create(), _options);
var model = await content.ReadFromMessagePackAsync <SimpleType>(_options);
model.Verify();
}
public void Create_InputValueInvalidType_ThrowsException()
{
var exception = Assert.Throws <ArgumentException>(() =>
MessagePackContent.Create(new SimpleType(), typeof(int),
MessagePackSerializerOptions.Standard, MessagePackDefaults.MediaTypeHeader));
Assert.Equal(
$"The specified type {typeof(int)} must derive from the specific value's type {typeof(SimpleType)}.",
exception.Message);
}
public async Task ReadAsStreamArrayAsync_NullObject_Test()
{
var content = MessagePackContent.Create <SimpleType>(null, _options, _mediaType);
await using var stream = await content.ReadAsStreamAsync();
var model = await MessagePackSerializer.DeserializeAsync <SimpleType>(stream, _options);
Assert.Null(model);
}
public async Task GetFromMessagePackAsync_Generic_StringUri_Test()
{
_handler.ResponseContent = MessagePackContent.Create(SimpleType.Create(), _options);
var result =
await _client.GetFromMessagePackAsync <SimpleType>(_uri, _options, CancellationToken.None);
Assert.NotNull(result);
result.Verify();
}
public async Task ReadFromMessagePackAsync_Test()
{
var content = MessagePackContent.Create(SimpleType.Create(), _options);
var model = await content.ReadFromMessagePackAsync(typeof(SimpleType), _options);
var simpleType = Assert.IsType <SimpleType>(model);
simpleType.Verify();
}
public void Create_Generic_DefaultPropertyValues_Test()
{
var inputValue = SimpleType.Create();
var content = MessagePackContent.Create(inputValue);
Assert.Same(inputValue, content.Value);
Assert.Same(typeof(SimpleType), content.ObjectType);
Assert.Same(MessagePackDefaults.MediaTypeHeader, content.Headers.ContentType);
Assert.Same(MessagePackDefaults.SerializerOptions, content.SerializerOptions);
}
public void Create_Generic_Test()
{
var inputValue = SimpleType.Create();
var content = MessagePackContent.Create(inputValue, _options, _mediaType);
Assert.Same(inputValue, content.Value);
Assert.Same(typeof(SimpleType), content.ObjectType);
Assert.Same(_mediaType, content.Headers.ContentType);
Assert.Same(_options, content.SerializerOptions);
}
public async Task ReadAsStreamArrayAsync_Test()
{
var inputValue = SimpleType.Create();
var content = MessagePackContent.Create(inputValue, _options, _mediaType);
await using var stream = await content.ReadAsStreamAsync();
var model = await MessagePackSerializer.DeserializeAsync <SimpleType>(stream, _options);
model.Verify();
}
public async Task GetFromMessagePackAsync_StringUri_Test()
{
_handler.ResponseContent = MessagePackContent.Create(SimpleType.Create(), _options);
var result =
await _client.GetFromMessagePackAsync(_uri, typeof(SimpleType), _options, CancellationToken.None);
Assert.Contains(MessagePackDefaults.MediaTypeHeader, _handler.Request.Headers.Accept);
Assert.NotNull(result);
var model = Assert.IsType <SimpleType>(result);
model.Verify();
}
public async Task CopyToAsync_NullObject_Test()
{
var content = MessagePackContent.Create <SimpleType>(null, _options, _mediaType);
await using var stream = new MemoryStream();
await content.CopyToAsync(stream);
stream.Position = 0;
var model = await MessagePackSerializer.DeserializeAsync <SimpleType>(stream, _options);
Assert.Null(model);
}
public async Task MessagePackContent_StreamSerialized()
{
var o = new TestObject()
{
Id = 1, Text = "..."
};
var content = new MessagePackContent(o);
var stream = await content.ReadAsStreamAsync();
Assert.NotNull(stream);
var o2 = MessagePackSerializer.Deserialize <TestObject>(stream);
Assert.Equal(o.Id, o2.Id);
}
public async Task CopyToAsync_Test()
{
var inputValue = SimpleType.Create();
var content = MessagePackContent.Create(inputValue, _options, _mediaType);
await using var stream = new MemoryStream();
await content.CopyToAsync(stream);
stream.Position = 0;
var model = await MessagePackSerializer.DeserializeAsync <SimpleType>(stream, _options);
model.Verify();
}
/// <inheritdoc />
public override async Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
TransportContext transportContext,
CancellationToken cancellationToken)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (writeStream is null)
{
throw new ArgumentNullException(nameof(writeStream));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
var messagePackContent = content as MessagePackContent ?? MessagePackContent.Create(value, type, SerializerOptions);
await messagePackContent.CopyToAsync(writeStream).ConfigureAwait(false);
content.Headers.ContentLength = messagePackContent.Headers.ContentLength;
}
