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); }