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 ConvertCollectionDoubleToDoubleArray()
{
var context = new TestConverterContext("output", typeof(double[]), _sourceDoubleEnumerable);
Assert.True(_converter.TryConvert(context, out object target));
TestUtility.AssertIsTypeAndConvert <double[]>(target);
}
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 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 Verify_Success_Result_Properties()
{
var conversionResult = ConversionResult.Success(value: "foo");
Assert.Equal(ConversionStatus.Succeeded, conversionResult.Status);
Assert.Null(conversionResult.Error);
var convertedValue = TestUtility.AssertIsTypeAndConvert <string>(conversionResult.Value);
Assert.Equal("foo", convertedValue);
}
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 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 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 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 async Task Convert_Using_Default_Converters_Guid()
{
var converterContext = CreateConverterContext(typeof(Guid), "0c67c078-7213-4e91-ad41-f8747c865f3d");
var actual = await _defaultInputConversionFeature.ConvertAsync(converterContext);
Assert.Equal(ConversionStatus.Succeeded, actual.Status);
var value = TestUtility.AssertIsTypeAndConvert <Guid>(actual.Value);
Assert.Equal("0c67c078-7213-4e91-ad41-f8747c865f3d", value.ToString());
}
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 async Task Convert_Using_Converter_From_InputConverterAttribute_Of_TargetType()
{
// Target type used is "Customer" which has an "InputConverter" decoration
// to use the "MyCustomerAsyncInputConverter" converter.
var converterContext = CreateConverterContext(typeof(Customer), "16");
var actual = await _defaultInputConversionFeature.ConvertAsync(converterContext);
Assert.Equal(ConversionStatus.Succeeded, actual.Status);
var customer = TestUtility.AssertIsTypeAndConvert <Customer>(actual.Value);
Assert.Equal("16-converted customer", customer.Name);
}
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 Convert_Using_Converter_Specified_In_ConverterContext_Properties()
{
// Explicitly specify a converter to be used via ConverterContext.Properties.
IReadOnlyDictionary <string, object> properties = new Dictionary <string, object>()
{
{ PropertyBagKeys.ConverterType, typeof(MySimpleSyncInputConverter).AssemblyQualifiedName }
};
var converterContext = CreateConverterContext(typeof(string), "0c67c078-7213-4e91-ad41-f8747c865f3d", properties);
var actual = await _defaultInputConversionFeature.ConvertAsync(converterContext);
Assert.Equal(ConversionStatus.Succeeded, actual.Status);
Assert.Equal("0c67c078-7213-4e91-ad41-f8747c865f3d-converted value", actual.Value);
TestUtility.AssertIsTypeAndConvert <string>(actual.Value);
}
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 Convert_Using_Default_Converters_JSON_Poco()
{
// 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 converterContext = CreateConverterContext(typeof(IReadOnlyList <Book>), source);
var actual = await _defaultInputConversionFeature.ConvertAsync(converterContext);
Assert.Equal(ConversionStatus.Succeeded, actual.Status);
var targetEnum = TestUtility.AssertIsTypeAndConvert <IReadOnlyList <Book> >(actual.Value);
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);
}
