private string ReduceHeaders(HttpHeaders headers)
{
if (headers?.Count() == 0)
{
return(string.Empty);
}
// Filter any headers here if required
return(Aggregate(headers?.Select(h => $"{h.Key}:{Aggregate(h.Value)}")));
}
public static void CopyHeaders(HttpHeaders source, HttpHeaders destination)
{
if (source != null && source.Count() != 0)
{
foreach (var header in source)
{
destination.TryAddWithoutValidation(header.Key, header.Value);
}
}
}
/// <summary>
/// Конвертирует HTTP-заголовки в словарь
/// </summary>
/// <param name="headers">HTTP-заголовки</param>
/// <returns>Cловарь</returns>
public static IDictionary <string, string> ConvertHeaders(HttpHeaders headers)
{
var convHeaders = new Dictionary <string, string>(headers.Count());
foreach (var header in headers)
{
convHeaders.Add(header.Key, string.Join(";", header.Value));
}
return(convHeaders);
}
public void HPack_HeaderEncodeDecodeRoundtrip_ShouldMatchOriginalInput(HttpHeaders headers)
{
Memory <byte> encoding = HPackEncode(headers);
HttpHeaders decodedHeaders = HPackDecode(encoding);
// Assert: decoded headers are structurally equal to original headers
Assert.Equal(headers.Count(), decodedHeaders.Count());
Assert.All(headers.Zip(decodedHeaders), pair =>
{
Assert.Equal(pair.First.Key, pair.Second.Key);
Assert.Equal(pair.First.Value, pair.Second.Value);
});
}
/// <summary>
/// Converts the specified HTTP headers.
/// </summary>
/// <param name="httpHeaders">The HTTP headers.</param>
/// <returns>IDictionary<System.String, System.String>.</returns>
private IDictionary <string, string> Convert(HttpHeaders httpHeaders)
{
if (httpHeaders == null)
{
return(null);
}
Dictionary <string, string> headers = new Dictionary <string, string>(httpHeaders.Count());
foreach (var httpHeader in httpHeaders)
{
headers[httpHeader.Key] = httpHeader.Value.Aggregate(string.Empty, (combined, next) => combined += (next + ", "));
}
return(headers);
}
private void ValidateHeadersCount(
IEnumerable <KeyValuePair <string, IEnumerable <string> > > expectedHeaders,
HttpHeaders actualHeaders,
bool isContentHeaders = false)
{
var actualHeadersCount = actualHeaders.Count();
var expectedHeadersCount = expectedHeaders.Count();
if (expectedHeadersCount != actualHeadersCount)
{
this.ThrowNewHttpResponseMessageAssertionException(
isContentHeaders ? "content headers" : "headers",
string.Format("to be {0}", expectedHeadersCount),
string.Format("were in fact {0}", actualHeadersCount));
}
}
/// <summary>
/// Validates total number of HTTP headers.
/// </summary>
/// <param name="expectedHeaders">Expected HTTP headers.</param>
/// <param name="actualHeaders">Actual HTTP headers.</param>
/// <param name="failedValidationAction">Action to call in case of failed validation.</param>
/// <param name="isContentHeaders">Indicates whether the headers are content headers.</param>
public static void ValidateHeadersCount(
IEnumerable <KeyValuePair <string, IEnumerable <string> > > expectedHeaders,
HttpHeaders actualHeaders,
Action <string, string, string> failedValidationAction,
bool isContentHeaders = false)
{
var actualHeadersCount = actualHeaders.Count();
var expectedHeadersCount = expectedHeaders.Count();
if (expectedHeadersCount != actualHeadersCount)
{
failedValidationAction(
isContentHeaders ? "content headers" : "headers",
string.Format("to be {0}", expectedHeadersCount),
string.Format("were in fact {0}", actualHeadersCount));
}
}
/// <summary>
/// Converts the specified HTTP headers.
/// </summary>
/// <param name="httpHeaders">The HTTP headers.</param>
/// <returns>IDictionary<System.String, System.String>.</returns>
private static IDictionary <string, string> Convert(HttpHeaders httpHeaders)
{
if (httpHeaders == null)
{
return(new Dictionary <string, string>(0));
}
Dictionary <string, string> headers = new(httpHeaders.Count());
foreach (var httpHeader in httpHeaders)
{
StringBuilder valueBuilder = new();
foreach (var item in httpHeader.Value)
{
valueBuilder.Append(item + ", ");
}
headers[httpHeader.Key] = valueBuilder.ToString().TrimEnd(' ').TrimEnd(',');
}
return(headers);
}
/// <summary>
/// Asserts that the expected <see cref="HttpHeaders"/> instance is equal to the actual <see cref="actualHeaders"/> instance.
/// </summary>
/// <param name="expectedHeaders">The expected <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
/// <param name="actualHeaders">The actual <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
public void Equal(HttpHeaders expectedHeaders, HttpHeaders actualHeaders)
{
Assert.NotNull(expectedHeaders);
Assert.NotNull(actualHeaders);
Assert.Equal(expectedHeaders.Count(), actualHeaders.Count());
foreach (KeyValuePair <string, IEnumerable <string> > expectedHeader in expectedHeaders)
{
KeyValuePair <string, IEnumerable <string> > actualHeader = actualHeaders.FirstOrDefault(h => h.Key == expectedHeader.Key);
if (expectedHeader.Key == "Date")
{
HandleDateHeader(expectedHeader.Value.ToArray(), actualHeader.Value.ToArray());
}
else
{
string expectedHeaderStr = string.Join(CommaSeperator, expectedHeader.Value);
string actualHeaderStr = string.Join(CommaSeperator, actualHeader.Value);
Assert.Equal(expectedHeaderStr, actualHeaderStr);
}
}
}
/// <summary>
/// Asserts that the expected <see cref="HttpHeaders"/> instance is equal to the actual <see cref="actualHeaders"/> instance.
/// </summary>
/// <param name="expectedHeaders">The expected <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
/// <param name="actualHeaders">The actual <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
public static void AreEqual(HttpHeaders expectedHeaders, HttpHeaders actualHeaders)
{
Assert.IsNotNull(expectedHeaders, "The 'expectedHeaders' parameter should not be null.");
Assert.IsNotNull(actualHeaders, "The 'actualHeaders' parameter should not be null.");
Assert.AreEqual(expectedHeaders.Count(), actualHeaders.Count(), "The number of headers should have been the same.");
foreach (KeyValuePair <string, IEnumerable <string> > expectedHeader in expectedHeaders)
{
KeyValuePair <string, IEnumerable <string> > actualHeader = actualHeaders.FirstOrDefault(h => h.Key == expectedHeader.Key);
Assert.IsNotNull(actualHeader, string.Format("The '{0}' header was expected but not found.", expectedHeader.Key));
if (expectedHeader.Key == "Date")
{
HandleDateHeader(expectedHeader.Value.ToArray(), actualHeader.Value.ToArray());
}
else
{
string expectedHeaderStr = string.Join(CommaSeperator, expectedHeader.Value);
string actualHeaderStr = string.Join(CommaSeperator, actualHeader.Value);
Assert.AreEqual(expectedHeaderStr, actualHeaderStr, string.Format("The '{0}' header disagreed with the expected header value.", expectedHeader.Key));
}
}
}
/// <summary>
/// Asserts that the expected <see cref="HttpHeaders"/> instance is equal to the actual <see cref="actualHeaders"/> instance.
/// </summary>
/// <param name="expectedHeaders">The expected <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
/// <param name="actualHeaders">The actual <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
public void Equal(HttpHeaders expectedHeaders, HttpHeaders actualHeaders)
{
Assert.NotNull(expectedHeaders);
Assert.NotNull(actualHeaders);
Assert.Equal(expectedHeaders.Count(), actualHeaders.Count());
foreach (KeyValuePair<string, IEnumerable<string>> expectedHeader in expectedHeaders)
{
KeyValuePair<string, IEnumerable<string>> actualHeader = actualHeaders.FirstOrDefault(h => h.Key == expectedHeader.Key);
Assert.NotNull(actualHeader);
if (expectedHeader.Key == "Date")
{
HandleDateHeader(expectedHeader.Value.ToArray(), actualHeader.Value.ToArray());
}
else
{
string expectedHeaderStr = string.Join(CommaSeperator, expectedHeader.Value);
string actualHeaderStr = string.Join(CommaSeperator, actualHeader.Value);
Assert.Equal(expectedHeaderStr, actualHeaderStr);
}
}
}
/// <summary>
/// Asserts that the expected <see cref="HttpHeaders"/> instance is equal to the actual <see cref="actualHeaders"/> instance.
/// </summary>
/// <param name="expectedHeaders">The expected <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
/// <param name="actualHeaders">The actual <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
public static void AreEqual(HttpHeaders expectedHeaders, HttpHeaders actualHeaders)
{
Assert.IsNotNull(expectedHeaders, "The 'expectedHeaders' parameter should not be null.");
Assert.IsNotNull(actualHeaders, "The 'actualHeaders' parameter should not be null.");
Assert.AreEqual(expectedHeaders.Count(), actualHeaders.Count(), "The number of headers should have been the same.");
foreach (KeyValuePair<string, IEnumerable<string>> expectedHeader in expectedHeaders)
{
KeyValuePair<string, IEnumerable<string>> actualHeader = actualHeaders.FirstOrDefault(h => h.Key == expectedHeader.Key);
Assert.IsNotNull(actualHeader, string.Format("The '{0}' header was expected but not found.", expectedHeader.Key));
if (expectedHeader.Key == "Date")
{
HandleDateHeader(expectedHeader.Value.ToArray(), actualHeader.Value.ToArray());
}
else
{
string expectedHeaderStr = string.Join(CommaSeperator, expectedHeader.Value);
string actualHeaderStr = string.Join(CommaSeperator, actualHeader.Value);
Assert.AreEqual(expectedHeaderStr, actualHeaderStr, string.Format("The '{0}' header disagreed with the expected header value.", expectedHeader.Key));
}
}
}
public void HttpHeadersAddTest()
{
var HttpHeaders = new HttpHeaders();
Assert.AreEqual("[]", HttpHeaders.AsEnumerable<HttpHeader>().ToJsonString());
HttpHeaders.Add("Content-Type", "text/html");
HttpHeaders.Set("Content-Type", "text/plain");
HttpHeaders.Set("cOntEnt-type", "text/plain");
Assert.AreEqual(1, HttpHeaders.Count());
Assert.AreEqual("cOntEnt-type: text/plain", String.Join("|", HttpHeaders.AsEnumerable()));
}