public static Task WriteContentUsingCorrectCharacterEncodingHelper(MediaTypeFormatter formatter, string content, byte[] expectedData, string mediaType)
{
// Arrange
MemoryStream memStream = new MemoryStream();
StringContent dummyContent = new StringContent(string.Empty);
HttpContentHeaders headers = dummyContent.Headers;
headers.Clear();
headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
headers.ContentLength = expectedData.Length;
IFormatterLogger mockFormatterLogger = new Mock <IFormatterLogger>().Object;
// Act & Assert
return(formatter.WriteToStreamAsync(typeof(string), content, memStream, dummyContent, null).ContinueWith(
(writeTask) =>
{
// Assert
Assert.Equal(TaskStatus.RanToCompletion, writeTask.Status);
byte[] actualData = memStream.ToArray();
Assert.Equal(expectedData, actualData);
}));
}
protected async Task ReadFromStreamAsync_UsesCorrectCharacterEncodingHelper(MediaTypeFormatter formatter, string content, string formattedContent, string mediaType, string encoding, bool isDefaultEncoding)
{
// Arrange
Encoding enc = null;
if (isDefaultEncoding)
{
enc = formatter.SupportedEncodings.First((e) => e.WebName.Equals(encoding, StringComparison.OrdinalIgnoreCase));
}
else
{
enc = Encoding.GetEncoding(encoding);
formatter.SupportedEncodings.Add(enc);
}
byte[] data = enc.GetBytes(formattedContent);
MemoryStream memStream = new MemoryStream(data);
StringContent dummyContent = new StringContent(string.Empty);
HttpContentHeaders headers = dummyContent.Headers;
headers.Clear();
headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
headers.ContentLength = data.Length;
IFormatterLogger mockFormatterLogger = new Mock <IFormatterLogger>().Object;
// Act
string result = (await formatter.ReadFromStreamAsync(typeof(string), memStream, dummyContent, mockFormatterLogger)) as string;
// Assert
Assert.Equal(content, result);
}
public static Task ReadContentUsingCorrectCharacterEncodingHelper(MediaTypeFormatter formatter, string content, byte[] sourceData, string mediaType)
{
// Arrange
MemoryStream memStream = new MemoryStream(sourceData);
StringContent dummyContent = new StringContent(string.Empty);
HttpContentHeaders headers = dummyContent.Headers;
headers.Clear();
headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
headers.ContentLength = sourceData.Length;
IFormatterLogger mockFormatterLogger = new Mock <IFormatterLogger>().Object;
// Act & Assert
return(formatter.ReadFromStreamAsync(typeof(string), memStream, dummyContent, mockFormatterLogger).ContinueWith(
(readTask) =>
{
string result = readTask.Result as string;
// Assert
Assert.Equal(TaskStatus.RanToCompletion, readTask.Status);
Assert.Equal(content, result);
}));
}
protected static async Task WriteContentUsingCorrectCharacterEncodingHelperAsync(
MediaTypeFormatter formatter,
string content,
byte[] expectedData,
string mediaType
)
{
// Arrange
MemoryStream memStream = new MemoryStream();
StringContent dummyContent = new StringContent(string.Empty);
HttpContentHeaders headers = dummyContent.Headers;
headers.Clear();
headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
headers.ContentLength = expectedData.Length;
IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;
// Act
await formatter.WriteToStreamAsync(
typeof(string),
content,
memStream,
dummyContent,
null
);
// Assert
byte[] actualData = memStream.ToArray();
Assert.Equal(expectedData, actualData);
}
protected static async Task ReadContentUsingCorrectCharacterEncodingHelperAsync(
MediaTypeFormatter formatter,
string content,
byte[] sourceData,
string mediaType
)
{
// Arrange
MemoryStream memStream = new MemoryStream(sourceData);
StringContent dummyContent = new StringContent(string.Empty);
HttpContentHeaders headers = dummyContent.Headers;
headers.Clear();
headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
headers.ContentLength = sourceData.Length;
IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;
// Act
var result =
(
await formatter.ReadFromStreamAsync(
typeof(string),
memStream,
dummyContent,
mockFormatterLogger
)
) as string;
// Assert
Assert.Equal(content, result);
}
/// <summary>
/// Replaces the headers.
/// </summary>
/// <param name="currentHeaders">The current headers.</param>
/// <param name="oldHeaders">The old headers.</param>
private void ReplaceHeaders(HttpContentHeaders currentHeaders, HttpContentHeaders oldHeaders)
{
currentHeaders.Clear();
foreach (var item in oldHeaders)
{
currentHeaders.Add(item.Key, item.Value);
}
}
public void ContentType_UseAddMethodWithInvalidValue_InvalidValueRecognized()
{
_headers.TryAddWithoutValidation("Content-Type", "text/plain; charset=utf-8; custom=value, other/type");
Assert.Null(_headers.ContentType);
Assert.Equal(1, _headers.GetValues("Content-Type").Count());
Assert.Equal("text/plain; charset=utf-8; custom=value, other/type",
_headers.GetValues("Content-Type").First());
_headers.Clear();
_headers.TryAddWithoutValidation("Content-Type", ",text/plain"); // leading separator
Assert.Null(_headers.ContentType);
Assert.Equal(1, _headers.GetValues("Content-Type").Count());
Assert.Equal(",text/plain", _headers.GetValues("Content-Type").First());
_headers.Clear();
_headers.TryAddWithoutValidation("Content-Type", "text/plain,"); // trailing separator
Assert.Null(_headers.ContentType);
Assert.Equal(1, _headers.GetValues("Content-Type").Count());
Assert.Equal("text/plain,", _headers.GetValues("Content-Type").First());
}
protected async Task WriteToStreamAsync_UsesCorrectCharacterEncodingHelper(
MediaTypeFormatter formatter,
string content,
string formattedContent,
string mediaType,
string encoding,
bool isDefaultEncoding
)
{
// Arrange
Encoding enc = null;
if (isDefaultEncoding)
{
enc = formatter.SupportedEncodings.First(
(e) => e.WebName.Equals(encoding, StringComparison.OrdinalIgnoreCase)
);
}
else
{
enc = Encoding.GetEncoding(encoding);
formatter.SupportedEncodings.Add(enc);
}
byte[] preamble = enc.GetPreamble();
byte[] data = enc.GetBytes(formattedContent);
byte[] expectedData = new byte[preamble.Length + data.Length];
Buffer.BlockCopy(preamble, 0, expectedData, 0, preamble.Length);
Buffer.BlockCopy(data, 0, expectedData, preamble.Length, data.Length);
MemoryStream memStream = new MemoryStream();
HttpContent httpContent = new StringContent(String.Empty);
HttpContentHeaders contentHeaders = httpContent.Headers;
contentHeaders.Clear();
contentHeaders.ContentType = MediaTypeHeaderValue.Parse(mediaType);
contentHeaders.ContentLength = expectedData.Length;
IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;
// Act
await formatter.WriteToStreamAsync(
typeof(string),
content,
memStream,
httpContent,
null
);
// Assert
byte[] actualData = memStream.ToArray();
Assert.Equal(expectedData, actualData);
}
public static Task WriteContentUsingCorrectCharacterEncodingHelper(MediaTypeFormatter formatter, string content, string formattedContent, string mediaType, string encoding, bool isDefaultEncoding)
{
// Arrange
Encoding enc = null;
if (isDefaultEncoding)
{
enc = formatter.SupportedEncodings.First((e) => e.WebName.Equals(encoding, StringComparison.OrdinalIgnoreCase));
}
else
{
enc = Encoding.GetEncoding(encoding);
formatter.SupportedEncodings.Add(enc);
}
byte[] preamble = enc.GetPreamble();
byte[] data = enc.GetBytes(formattedContent);
byte[] expectedData = new byte[preamble.Length + data.Length];
Buffer.BlockCopy(preamble, 0, expectedData, 0, preamble.Length);
Buffer.BlockCopy(data, 0, expectedData, preamble.Length, data.Length);
MemoryStream memStream = new MemoryStream();
StringContent dummyContent = new StringContent(string.Empty);
HttpContentHeaders headers = dummyContent.Headers;
headers.Clear();
headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
headers.ContentLength = expectedData.Length;
IFormatterLogger mockFormatterLogger = new Mock <IFormatterLogger>().Object;
// Act
return(formatter.WriteToStreamAsync(typeof(string), content, memStream, dummyContent, null).ContinueWith(
(writeTask) =>
{
// Assert
Assert.Equal(TaskStatus.RanToCompletion, writeTask.Status);
byte[] actualData = memStream.ToArray();
Assert.Equal(expectedData, actualData);
}));
}
/// <summary>
/// Creates an empty <see cref="HttpContentHeaders"/> instance. The only way is to get it from a dummy
/// <see cref="HttpContent"/> instance.
/// </summary>
/// <returns>The created instance.</returns>
public static HttpContentHeaders CreateEmptyContentHeaders()
{
HttpContent tempContent = null;
HttpContentHeaders contentHeaders = null;
try
{
tempContent = new StringContent(string.Empty);
contentHeaders = tempContent.Headers;
contentHeaders.Clear();
}
finally
{
// We can dispose the content without touching the headers
if (tempContent != null)
{
tempContent.Dispose();
}
}
return(contentHeaders);
}
public static Task ReadContentUsingCorrectCharacterEncodingHelper(MediaTypeFormatter formatter, string content, string formattedContent, string mediaType, string encoding, bool isDefaultEncoding)
{
// Arrange
Encoding enc = null;
if (isDefaultEncoding)
{
enc = formatter.SupportedEncodings.First((e) => e.WebName.Equals(encoding, StringComparison.OrdinalIgnoreCase));
}
else
{
enc = Encoding.GetEncoding(encoding);
formatter.SupportedEncodings.Add(enc);
}
byte[] data = enc.GetBytes(formattedContent);
MemoryStream memStream = new MemoryStream(data);
StringContent dummyContent = new StringContent(string.Empty);
HttpContentHeaders headers = dummyContent.Headers;
headers.Clear();
headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
headers.ContentLength = data.Length;
IFormatterLogger mockFormatterLogger = new Mock <IFormatterLogger>().Object;
// Act
return(formatter.ReadFromStreamAsync(typeof(string), memStream, headers, mockFormatterLogger).ContinueWith(
(readTask) =>
{
string result = readTask.Result as string;
// Assert
Assert.Equal(TaskStatus.RanToCompletion, readTask.Status);
Assert.Equal(content, result);
}));
}
