public void WriteToStreamAsyncCallsOnWriteToStreamInTask() { Type calledType = null; object calledObj = null; Stream calledStream = null; HttpContentHeaders calledHeaders = null; Task createdTask = null; SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; formatter.OnWriteToStreamTypeObjectStreamHttpContentHeadersTransportContext = (type, obj, stream, headers, context) => { calledType = type; calledObj = obj; calledStream = stream; calledHeaders = headers; }; SHttpContent content = new SHttpContent(); HttpContentHeaders contentHeaders = content.Headers; StreamAssert.WriteAndRead( (stream) => createdTask = formatter.WriteToStreamAsync(typeof(int), 5, stream, contentHeaders, /*transportContext*/ null), (stream) => { }); TaskAssert.Succeeds(createdTask); Assert.AreEqual(typeof(int), calledType, "OnWriteToStream was not called or did not pass Type."); Assert.AreEqual(5, calledObj, "OnWriteToStream was not called or did not pass the object value."); Assert.IsNotNull(calledStream, "OnWriteToStream was not called or did not pass Type."); Assert.AreSame(contentHeaders, calledHeaders, "OnWriteToStream was not called or did not pass ContentHeaders."); }
public void ReadFromStreamAsyncCallsOnReadFromStreamInTask() { Type calledType = null; Stream calledStream = null; HttpContentHeaders calledHeaders = null; SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; formatter.OnReadFromStreamTypeStreamHttpContentHeaders = (type, stream, headers) => { calledType = type; calledStream = stream; calledHeaders = headers; return(5); }; SHttpContent content = new SHttpContent(); HttpContentHeaders contentHeaders = content.Headers; Task <object> createdTask = StreamAssert.WriteAndReadResult <Task <object> >( (stream) => { }, (stream) => formatter.ReadFromStreamAsync(typeof(int), stream, contentHeaders)); object readObject = TaskAssert.SucceedsWithResult(createdTask); Assert.AreEqual(5, readObject, "ReadFromStreamAsync should have returned this value from stub."); Assert.AreEqual(typeof(int), calledType, "OnReadFromStreamAsync was not called or did not pass Type."); Assert.IsNotNull(calledStream, "OnReadFromStreamAsync was not called or did not pass Type."); Assert.AreSame(contentHeaders, calledHeaders, "OnReadFromStreamAsync was not called or did not pass ContentHeaders."); }
public void CanReadTypeReturnsTrue() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; string[] legalMediaTypeStrings = HttpTestData.LegalMediaTypeStrings.ToArray(); foreach (string mediaType in legalMediaTypeStrings) { formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue(mediaType)); } TestDataAssert.Execute( TestData.RepresentativeValueAndRefTypeTestDataCollection, (type, obj) => { foreach (string mediaType in legalMediaTypeStrings) { SStringContent content = new SStringContent("data") { CallBase = true }; content.Headers.ContentType = new MediaTypeHeaderValue(mediaType); Assert.IsTrue(formatter.CanReadAs(type, content), string.Format("CanReadType should have returned true for '{0}'.", type)); } }); }
public void ReadFromStreamAsyncCallsOnReadFromStreamAsync() { Type calledType = null; Stream calledStream = null; HttpContentHeaders calledHeaders = null; SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; formatter.OnReadFromStreamAsyncTypeStreamHttpContentHeaders = (type, stream, headers) => { calledType = type; calledStream = stream; calledHeaders = headers; return(null); }; SHttpContent content = new SHttpContent(); HttpContentHeaders contentHeaders = content.Headers; StreamAssert.WriteAndRead( (stream) => { }, (stream) => formatter.ReadFromStreamAsync(typeof(int), stream, contentHeaders)); Assert.AreEqual(typeof(int), calledType, "OnReadFromStreamAsync was not called or did not pass Type."); Assert.IsNotNull(calledStream, "OnReadFromStreamAsync was not called or did not pass Type."); Assert.AreSame(contentHeaders, calledHeaders, "OnReadFromStreamAsync was not called or did not pass ContentHeaders."); }
public void CanWriteAs2ReturnsTrue() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; foreach (string mediaType in HttpTestData.LegalMediaTypeStrings) { formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue(mediaType)); } TestDataAssert.Execute( TestData.RepresentativeValueAndRefTypeTestDataCollection, (type, obj) => { MediaTypeHeaderValue matchedMediaType = null; SObjectContent objectContent = new SObjectContent(type, obj) { CallBase = true }; objectContent.Headers.ContentType = formatter.SupportedMediaTypes[0]; Assert.IsTrue(formatter.CanWriteAs(type, new HttpResponseMessage() { Content = objectContent }, out matchedMediaType), string.Format("CanWriteAs should have returned true for '{0}'.", type)); }); }
public void CanReadAs2ThrowsWithNullContent() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; ExceptionAssert.ThrowsArgumentNull("type", () => formatter.CanReadAs((Type)null, new HttpResponseMessage())); }
public void CanReadAsThrowsWithNullContent() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; ExceptionAssert.ThrowsArgumentNull("content", () => formatter.CanReadAs(typeof(int), (HttpContent)null)); }
public void CanWriteAs2ThrowsWithNullContent() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; MediaTypeHeaderValue mediaType = null; ExceptionAssert.ThrowsArgumentNull("type", () => formatter.CanWriteAs(null, new HttpResponseMessage(), out mediaType)); }
public void CanWriteAsThrowsWithNullContent() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; MediaTypeHeaderValue mediaType = null; ExceptionAssert.ThrowsArgumentNull("content", () => formatter.CanWriteAs(typeof(int), (HttpContent)null, out mediaType)); }
public void SupportedMediaTypesAddThrowsWithNullMediaType() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; Collection <MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes; ExceptionAssert.ThrowsArgumentNull( "item", () => supportedMediaTypes.Add(null)); }
public void CanReadAsThrowsWithNullType() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; SStringContent content = new SStringContent("data") { CallBase = true }; ExceptionAssert.ThrowsArgumentNull("type", () => formatter.CanReadAs(null, content)); }
public void Constructor() { HttpParameter hpd = new HttpParameter("x", typeof(int)); HttpParameter expectedContentParameter = new HttpParameter("x", typeof(HttpRequestMessage <int>)); SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; MediaTypeFormatter[] formatters = new MediaTypeFormatter[] { formatter }; RequestContentHandler handler = new RequestContentHandler(hpd, formatters); HttpParameterAssert.ContainsOnly(handler.InputParameters, HttpParameter.RequestMessage, "Failed to initialize input parameters to HttpRequestMessage."); HttpParameterAssert.ContainsOnly(handler.OutputParameters, expectedContentParameter, "Failed to initialize content parameter."); CollectionAssert.Contains(handler.Formatters, formatter, "Failed to accept mediaTypeFormatter."); }
public void SupportedMediaTypesIsMutable() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; Collection <MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes; MediaTypeHeaderValue[] mediaTypes = HttpTestData.LegalMediaTypeHeaderValues.ToArray(); foreach (MediaTypeHeaderValue mediaType in mediaTypes) { supportedMediaTypes.Add(mediaType); } CollectionAssert.AreEqual(mediaTypes, formatter.SupportedMediaTypes, "SupportedMediaTypes does not contain expected set of media types."); }
public void Constructor() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; Collection <MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes; Assert.IsNotNull(supportedMediaTypes, "SupportedMediaTypes was not initialized."); Assert.AreEqual(0, supportedMediaTypes.Count, "SupportedMediaTypes should be empty by default."); Collection <MediaTypeMapping> mappings = formatter.MediaTypeMappings; Assert.IsNotNull(mappings, "MediaTypeMappings was not initialized."); Assert.AreEqual(0, mappings.Count, "MediaTypeMappings should be empty by default."); }
public void MediaTypeMappingsIsMutable() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; Collection <MediaTypeMapping> mappings = formatter.MediaTypeMappings; MediaTypeMapping[] standardMappings = HttpTestData.StandardMediaTypeMappings.ToArray(); foreach (MediaTypeMapping mapping in standardMappings) { mappings.Add(mapping); } CollectionAssert.AreEqual(standardMappings, formatter.MediaTypeMappings, "MediaTypeMappings does not contain expected set of MediaTypeMapping elements."); }
public void SupportedMediaTypesInsertThrowsWithMediaRange() { SMediaTypeFormatter formatter = new SMediaTypeFormatter() { CallBase = true }; Collection <MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes; MediaTypeHeaderValue[] mediaRanges = HttpTestData.LegalMediaRangeValues.ToArray(); foreach (MediaTypeHeaderValue mediaType in mediaRanges) { ExceptionAssert.ThrowsArgument( "item", SR.CannotUseMediaRangeForSupportedMediaType(typeof(MediaTypeHeaderValue).Name, mediaType.MediaType), () => supportedMediaTypes.Insert(0, mediaType)); } }