public void Add_SingleFirstAddThenTryAddWithoutValidationToSingleValueHeader_BothParsedAndInvalidValue()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
headers.Add(knownHeader, rawPrefix + "1");
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "2");
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
// Add() succeeds since we don't have a value added yet. TryAddWithoutValidation() also succeeds, however
// the value is added to the 'invalid values' list when retrieved.
Assert.Equal(1, headers.Count());
Assert.Equal(2, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(rawPrefix + "2", headers.First().Value.ElementAt(1));
// Note that TryParseValue() is not called because HttpHeaders sees that there is already a value
// so it adds the raw value to 'invalid values'.
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
}
public void Add_SingleAddTwoValidValuesToHeaderWithSingleValue_Throw()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
try
{
headers.Add(knownHeader, rawPrefix + "1");
}
catch (Exception e)
{
Assert.True(false, string.Format("Adding the first header already threw exception: {0}", e));
}
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, rawPrefix + "2"); });
// Verify that the first header value is still there.
Assert.Equal(1, headers.First().Value.Count());
}
public void Add_SingleFirstTryAddWithoutValidationThenAddToSingleValueHeader_AddThrows()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "1");
Assert.Throws<FormatException>(() => {headers.Add(knownHeader, rawPrefix + "2"); });
}
public void TryAddWithoutValidation_AddMultipleValueToSingleValueHeaders_FirstHeaderAddedOthersAreInvalid()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "1");
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "2");
Assert.Equal(0, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(2, headers.First().Value.Count());
// Note that the first value was parsed and added to the 'parsed values' list. The second value however
// was added to the 'invalid values' list since the header doesn't support multiple values.
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(rawPrefix + "2", headers.First().Value.ElementAt(1));
// The parser is only called once for the first value. HttpHeaders doesn't invoke the parser for
// additional values if the parser only supports one value.
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
}
public void TryAddWithoutValidation_AddMultipleValueStringToSingleValueHeaders_MultipleValueStringAddedAsInvalid()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "1," + rawPrefix + "2");
Assert.Equal(0, headers.Parser.TryParseValueCallCount);
// Since parsing the header value fails because it is composed of 2 values, the original string is added
// to the list of 'invalid values'. Therefore we only have 1 header value (the original string).
Assert.Equal(1, headers.Count());
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal(rawPrefix + "1," + rawPrefix + "2", headers.First().Value.First());
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
}
public MockHeaders(MockHeaderParser parser)
: base()
{
Dictionary<string, HttpHeaderParser> parserStore = new Dictionary<string, HttpHeaderParser>();
this.parser = parser;
parserStore.Add(knownHeader, this.parser);
SetConfiguration(parserStore, new HashSet<string>());
}
public void GetHeaderStrings_SetMultipleValuesOnSingleValueHeader_AllHeaderValuesReturned()
{
MockHeaderParser parser = new MockHeaderParser(false);
MockHeaders headers = new MockHeaders(parser);
headers.TryAddWithoutValidation(knownHeader, "value1");
headers.TryAddWithoutValidation(knownHeader, rawPrefix);
foreach (var header in headers.GetHeaderStrings())
{
Assert.Equal(knownHeader, header.Key);
// Note that the added rawPrefix did not get parsed
Assert.Equal("value1, " + rawPrefix, header.Value);
}
}
public void GetHeaderStrings_SetMultipleHeaders_AllHeaderValuesReturned()
{
MockHeaderParser parser = new MockHeaderParser(true);
MockHeaders headers = new MockHeaders(parser);
// Add header value with invalid newline chars.
headers.Add(knownHeader, rawPrefix + "1");
headers.Add("header2", "value2");
headers.Add("header3", (string)null);
headers.Add("header4", "value41");
headers.Add("header4", "value42");
string[] expectedHeaderNames = { knownHeader, "header2", "header3", "header4" };
string[] expectedHeaderValues = { parsedPrefix + "1", "value2", "", "value41, value42" };
int i = 0;
foreach (var header in headers.GetHeaderStrings())
{
Assert.NotEqual(expectedHeaderNames.Length, i);
Assert.Equal(expectedHeaderNames[i], header.Key);
Assert.Equal(expectedHeaderValues[i], header.Value);
i++;
}
}
public void GetHeaderStrings_SetValidAndInvalidHeaderValues_AllHeaderValuesReturned()
{
MockHeaderParser parser = new MockHeaderParser("---");
MockHeaders headers = new MockHeaders(parser);
// Add header value with invalid newline chars.
headers.Add(knownHeader, rawPrefix + "1");
headers.TryAddWithoutValidation(knownHeader, "value2,value3");
headers.TryAddWithoutValidation(knownHeader, invalidHeaderValue);
foreach (var header in headers.GetHeaderStrings())
{
Assert.Equal(knownHeader, header.Key);
// Note that raw values don't get parsed but just added to the result.
Assert.Equal("value2,value3---" + invalidHeaderValue + "---" + parsedPrefix + "1", header.Value);
}
}
public void Add_SingleAddTwoValidValuesToHeaderWithSingleValue_Throw()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
headers.Add(knownHeader, rawPrefix + "1");
// Can only add headers once.
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, rawPrefix + "2"); });
// Verify that the first header value is still there.
Assert.Equal(1, headers.First().Value.Count());
}
