public void ConvertCollectionBytesToReadOnlyByteArray()
{
var context = new TestConverterContext("output", typeof(ReadOnlyMemory <byte>[]), _sourceMemoryEnumerable);
Assert.True(_converter.TryConvert(context, out object target));
TestUtility.AssertIsTypeAndConvert <ReadOnlyMemory <byte>[]>(target);
}
public void ConvertCollectionDoubleToDoubleArray()
{
var context = new TestConverterContext("output", typeof(double[]), _sourceDoubleEnumerable);
Assert.True(_converter.TryConvert(context, out object target));
TestUtility.AssertIsTypeAndConvert <double[]>(target);
}
public void ConvertCollectionSint64ToLongArray()
{
var context = new TestConverterContext("output", typeof(long[]), _sourceLongEnumerable);
Assert.True(_converter.TryConvert(context, out object target));
TestUtility.AssertIsTypeAndConvert <long[]>(target);
}
public void ExactMatch()
{
string source = "abc";
var context = new TestConverterContext("input", typeof(string), source);
Assert.True(_paramConverterManager.TryConvert(context, out object target));
Assert.Equal(source, target);
}
public async Task ConvertCollectionBytesToReadOnlyByteArray()
{
var context = new TestConverterContext(typeof(ReadOnlyMemory <byte>[]), _sourceMemoryEnumerable);
var conversionResult = await _converter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
TestUtility.AssertIsTypeAndConvert <ReadOnlyMemory <byte>[]>(conversionResult.Value);
}
public async Task ConvertCollectionDoubleToDoubleArray()
{
var context = new TestConverterContext(typeof(double[]), _sourceDoubleEnumerable);
var conversionResult = await _converter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
TestUtility.AssertIsTypeAndConvert <double[]>(conversionResult.Value);
}
public void SourceIsNotValidJsonString_ReturnsNull()
{
string source = "invalid string";
var context = new TestConverterContext("input", typeof(Book), source);
Assert.False(_jsonPocoConverter.TryConvert(context, out object target));
Assert.Null(target);
}
public async Task ConversionFailedForInvalidParameterType(object source, Type parameterType)
{
var context = new TestConverterContext(parameterType, source);
var conversionResult = await _converter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Unhandled, conversionResult.Status);
Assert.Null(conversionResult.Value);
}
public async Task ConversionFailedForInvalidSourceValue(object source)
{
var context = new TestConverterContext(typeof(Guid), source);
var conversionResult = await _converter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Unhandled, conversionResult.Status);
Assert.Null(conversionResult.Value);
}
public void ConvertToString()
{
var context = new TestConverterContext("output", typeof(string), _sourceMemory);
Assert.True(_converter.TryConvert(context, out object target));
var convertedString = TestUtility.AssertIsTypeAndConvert <string>(target);
Assert.Equal(_sourceString, convertedString);
}
public void ConvertToByteArray()
{
var context = new TestConverterContext("output", typeof(byte[]), _sourceMemory);
Assert.True(_converter.TryConvert(context, out object target));
var bytes = TestUtility.AssertIsTypeAndConvert <byte[]>(target);
Assert.Equal(_sourceBytes, bytes);
}
public async Task SourceIsNotValidJsonString_ReturnsNull()
{
string source = "invalid string";
var context = new TestConverterContext(typeof(Book), source);
var conversionResult = await _jsonPocoConverter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Failed, conversionResult.Status);
Assert.Null(conversionResult.Value);
Assert.NotNull(conversionResult.Error);
}
public async Task ConversionSuccessfulForValidSourceValueAsync(object source, Type parameterType)
{
var context = new TestConverterContext(parameterType, source);
var conversionResult = await _converter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
var convertedGuid = TestUtility.AssertIsTypeAndConvert <Guid>(conversionResult.Value);
Assert.Equal(Guid.Parse(source.ToString()), convertedGuid);
}
public async Task ConvertToString()
{
var context = new TestConverterContext(typeof(string), _sourceMemory);
var conversionResult = await _converter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
var convertedString = TestUtility.AssertIsTypeAndConvert <string>(conversionResult.Value);
Assert.Equal(_sourceString, convertedString);
}
public async Task ConvertToByteArray()
{
var context = new TestConverterContext(typeof(byte[]), _sourceMemory);
var conversionResult = await _converter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
var bytes = TestUtility.AssertIsTypeAndConvert <byte[]>(conversionResult.Value);
Assert.Equal(_sourceBytes, bytes);
}
public void SuccessfulConversion()
{
string source = "{ \"Title\": \"a\", \"Author\": \"b\" }";
var context = new TestConverterContext("input", typeof(Book), source);
Assert.True(_jsonPocoConverter.TryConvert(context, out object bookObj));
var book = TestUtility.AssertIsTypeAndConvert <Book>(bookObj);
Assert.Equal("a", book.Title);
Assert.Equal("b", book.Author);
}
public void SuccessfulConversion()
{
string source = "{ \"Title\": \"a\", \"Author\": \"b\" }";
var context = new TestConverterContext("input", typeof(Book), source);
Assert.True(_jsonPocoConverter.TryConvert(context, out object bookObj));
Book book = bookObj as Book;
Assert.NotNull(book);
Assert.Equal("a", book.Title);
Assert.Equal("b", book.Author);
}
public void ConvertMemory()
{
string source = "{ \"Title\": \"a\", \"Author\": \"b\" }";
var sourceMemory = new ReadOnlyMemory <byte>(Encoding.UTF8.GetBytes(source));
var context = new TestConverterContext("input", typeof(Book), sourceMemory);
Assert.True(_jsonPocoConverter.TryConvert(context, out object bookObj));
var book = TestUtility.AssertIsTypeAndConvert <Book>(bookObj);
Assert.Equal("a", book.Title);
Assert.Equal("b", book.Author);
}
public void ConvertJsonStringArrayToIEnumerableOfT()
{
var source = "[ \"a\", \"b\", \"c\" ]";
var context = new TestConverterContext("input", typeof(IEnumerable <string>), source);
Assert.True(_jsonPocoConverter.TryConvert(context, out object target));
var targetEnum = TestUtility.AssertIsTypeAndConvert <IEnumerable <string> >(target);
Assert.Collection(targetEnum,
p => Assert.True(p == "a"),
p => Assert.True(p == "b"),
p => Assert.True(p == "c"));
}
public async Task SuccessfulConversion()
{
string source = "{ \"Title\": \"a\", \"Author\": \"b\" }";
var context = new TestConverterContext(typeof(Book), source);
var conversionResult = await _jsonPocoConverter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
var book = TestUtility.AssertIsTypeAndConvert <Book>(conversionResult.Value);
Assert.Equal("a", book.Title);
Assert.Equal("b", book.Author);
}
public async Task ConvertMemory()
{
string source = "{ \"Title\": \"a\", \"Author\": \"b\" }";
var sourceMemory = new ReadOnlyMemory <byte>(Encoding.UTF8.GetBytes(source));
var context = new TestConverterContext(typeof(Book), sourceMemory);
var conversionResult = await _jsonPocoConverter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
var book = TestUtility.AssertIsTypeAndConvert <Book>(conversionResult.Value);
Assert.Equal("a", book.Title);
Assert.Equal("b", book.Author);
}
public void UpdatesExecutionContext()
{
var converter = new OutputBindingConverter();
var context = new TestConverterContext("output", typeof(OutputBinding <string>), null);
Assert.True(converter.TryConvert(context, out object target));
var outputBinding = TestUtility.AssertIsTypeAndConvert <OutputBinding <string> >(target);
outputBinding.SetValue("abc");
var outputs = context.ExecutionContext.OutputBindings;
Assert.Equal("abc", outputs["output"]);
}
public async Task ConvertJsonStringArrayToIEnumerableOfT()
{
var source = "[ \"a\", \"b\", \"c\" ]";
var context = new TestConverterContext(typeof(IEnumerable <string>), source);
var conversionResult = await _jsonPocoConverter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
var targetEnum = TestUtility.AssertIsTypeAndConvert <IEnumerable <string> >(conversionResult.Value);
Assert.Collection(targetEnum,
p => Assert.True(p == "a"),
p => Assert.True(p == "b"),
p => Assert.True(p == "c"));
}
public void Newtonsoft()
{
var options = new WorkerOptions
{
Serializer = new NewtonsoftJsonObjectSerializer()
};
var wrapper = new OptionsWrapper <WorkerOptions>(options);
var jsonPocoConverter = new JsonPocoConverter(wrapper);
string source = "{ \"title\": \"a\", \"Author\": \"b\" }";
var context = new TestConverterContext("input", typeof(NewtonsoftBook), source);
Assert.True(jsonPocoConverter.TryConvert(context, out object bookObj));
var book = TestUtility.AssertIsTypeAndConvert <NewtonsoftBook>(bookObj);
Assert.Equal("a", book.BookTitle);
Assert.Equal("b", book.BookAuthor);
}
public void JsonArrayToIReadOnlyListOfT()
{
// Simulate Cosmos for POCO with case insensitive json
var source =
@"[
{ ""id"": ""1"", ""author"": ""a"", ""title"": ""b"" },
{ ""id"": ""2"", ""author"": ""c"", ""title"": ""d"" },
{ ""id"": ""3"", ""author"": ""e"", ""title"": ""f"" }
]";
var context = new TestConverterContext("input", typeof(IReadOnlyList <Book>), source);
Assert.True(_paramConverterManager.TryConvert(context, out object target));
var targetEnum = TestUtility.AssertIsTypeAndConvert <IReadOnlyList <Book> >(target);
Assert.Collection(targetEnum,
p => Assert.True(p.Id == "1" && p.Author == "a"),
p => Assert.True(p.Id == "2" && p.Author == "c"),
p => Assert.True(p.Id == "3" && p.Author == "e"));
}
public async Task Newtonsoft()
{
var options = new WorkerOptions
{
Serializer = new NewtonsoftJsonObjectSerializer()
};
var wrapper = new OptionsWrapper <WorkerOptions>(options);
var jsonPocoConverter = new JsonPocoConverter(wrapper);
string source = "{ \"title\": \"a\", \"Author\": \"b\" }";
var context = new TestConverterContext(typeof(NewtonsoftBook), source);
var conversionResult = await jsonPocoConverter.ConvertAsync(context);
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
var book = TestUtility.AssertIsTypeAndConvert <NewtonsoftBook>(conversionResult.Value);
Assert.Equal("a", book.BookTitle);
Assert.Equal("b", book.BookAuthor);
}