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