public void ReadActionsWorkWhenReadOnly()
{
var headers = new HeaderDictionary(
new Dictionary <string, StringValues>(StringComparer.OrdinalIgnoreCase)
{
{ "Header1", "Value1" }
});
headers.IsReadOnly = true;
Assert.Single(headers);
Assert.Equal <string>(new[] { "Header1" }, headers.Keys);
Assert.True(headers.ContainsKey("header1"));
Assert.False(headers.ContainsKey("header2"));
Assert.Equal("Value1", headers["header1"]);
Assert.Equal(new[] { "Value1" }, headers["header1"].ToArray());
}
public HeaderDictionary Transform(HeaderDictionary headerDictionary)
{
if (!headerDictionary.ContainsKey(HeaderName))
{
// adding default value
headerDictionary.Add(HeaderName, "Google Chrome on Windows");
}
return(headerDictionary);
}
public void StripHeaders_Should_ignore_case_When_parsing_whitelist(string key)
{
var headers = new HeaderDictionary
{
{ key.ToUpper(), _precomputedTestValue }
};
headers = headers.StripHeaders() as HeaderDictionary;
Assert.True(headers.ContainsKey(key.ToUpper()));
}
public void StripHeaders_Internal_Should_accept_override_headers(string key)
{
var headers = new HeaderDictionary
{
{ key, _precomputedTestValue }
};
headers = headers.StripHeaders() as HeaderDictionary;
Assert.True(headers.ContainsKey(key));
}
void SetupDefaultLanguage()
{
if (HeaderDictionary.ContainsKey(Application.systemLanguage) == true)
{
// Set the default language
defaultLanguage = HeaderDictionary[Application.systemLanguage].Header;
if (Debug.isDebugBuild == true)
{
Debug.Log("Retrieved default language from system: " + defaultLanguage);
}
}
}
public void AddIfNotSet_ExpectHeaderToBeAdded()
{
// arrange
IHeaderDictionary headers = new HeaderDictionary();
// act
headers = headers.AddHeaderIfNotSet("X-Correlation-ID", "123");
// assert
Assert.True(headers.ContainsKey("X-Correlation-ID"));
Assert.Equal("123", headers["X-Correlation-ID"]);
}
Request(Stream stream, StreamWriter sw, string path, string method, HeaderDictionary headers, byte[] body)
{
Stream = stream;
StreamWriter = sw;
if (path.Contains("?"))
{
string query;
(RealPath, query) = path.Split('?', 2);
Query = ParseQueryOrPost(query);
}
else
{
RealPath = path;
Query = new Dictionary <string, string>();
}
Method = method;
Headers = headers;
Body = body;
if (headers.ContainsKey("Content-Type") && headers["Content-Type"] == "application/x-www-form-urlencoded")
{
PostParameters = ParseQueryOrPost(Encoding.UTF8.GetString(Body));
}
if (headers.ContainsKey("Cookie"))
{
Cookies = headers.GetList("Cookie").Select(
x => x.Split(';').Select(y => y.Trim().Split('=', 2)).Where(y => y.Length == 2))
.SelectMany(x => x)
.ToDictionary(x => x[0], x => x[1]);
}
else
{
Cookies = new Dictionary <string, string>();
}
}
public void OnActionExecuting_ForwardNotRequiredAndValidAndDoesNotHaveHeader_NoChange()
{
var requestHeaders = new HeaderDictionary();
var responseHeaders = new HeaderDictionary();
this.httpContextMock.SetupGet(x => x.Request).Returns(this.httpRequestMock.Object);
this.httpRequestMock.SetupGet(x => x.Headers).Returns(requestHeaders);
this.filter.Forward = true;
this.filter.Required = false;
this.filter.Valid = true;
this.filter.OnActionExecuting(this.actionExecutingContext);
Assert.False(responseHeaders.ContainsKey(HttpHeaderName));
}
public void AddFromEntity_LastModified_WhenUpdatedAt()
{
// Arrange
var headers = new HeaderDictionary();
var entity = new InMemoryEntity {
Version = null, UpdatedAt = DateTimeOffset.Parse("2019-01-30T13:30:15Z")
};
// Act
headers.AddFromEntity(entity);
// Assert
Assert.False(headers.ContainsKey("ETag"));
Assert.Single(headers["Last-Modified"]);
Assert.Equal("Wed, 30 Jan 2019 13:30:15 GMT", headers["Last-Modified"][0]);
}
public void AddFromEntity_ETag_WhenValidVersion()
{
// Arrange
var headers = new HeaderDictionary();
var entity = new InMemoryEntity {
Version = testVersion, UpdatedAt = default
};
// Act
headers.AddFromEntity(entity);
// Assert
Assert.Single(headers["ETag"]);
Assert.Equal(testETag, headers["ETag"][0]);
Assert.False(headers.ContainsKey("Last-Modified"));
}
public void AddIfNotSet_HeaderAlreadySet_ExpectKeepingOldValue()
{
// arrange
IHeaderDictionary headers = new HeaderDictionary
{
["X-Correlation-ID"] = "123"
};
// act
// (try to set correlation ID "999")
headers = headers.AddHeaderIfNotSet("X-Correlation-ID", "999");
// assert
Assert.True(headers.ContainsKey("X-Correlation-ID"));
Assert.Equal("123", headers["X-Correlation-ID"]);
}
void SetupDefaultLanguage()
{
// Check to see if default language isn't set yet
if (HeaderDictionary.ContainsKey(Application.systemLanguage) == true)
{
// Grab the default language from the system settings
DefaultLanguage = HeaderDictionary[Application.systemLanguage];
}
// Check if the default language is set
if ((string.IsNullOrEmpty(DefaultLanguage) == true) || (SupportedLanguages.Contains(DefaultLanguage) == false))
{
// If not, grab the first language in the headers
DefaultLanguage = SupportedLanguages[0];
}
}
public void OnActionExecuting_ForwardRequiredAndValidAndHasHeader_HeaderAddedToResponse()
{
var requestHeaders = new HeaderDictionary()
{
{ HttpHeaderName, "Hello" }
};
var responseHeaders = new HeaderDictionary();
this.httpContextMock.SetupGet(x => x.Request).Returns(this.httpRequestMock.Object);
this.httpContextMock.SetupGet(x => x.Response).Returns(this.httpResponseMock.Object);
this.httpRequestMock.SetupGet(x => x.Headers).Returns(requestHeaders);
this.httpResponseMock.SetupGet(x => x.Headers).Returns(responseHeaders);
this.filter.Forward = true;
this.filter.Required = true;
this.filter.Valid = true;
this.filter.OnActionExecuting(this.actionExecutingContext);
Assert.True(responseHeaders.ContainsKey(HttpHeaderName));
Assert.Single(responseHeaders[HttpHeaderName]);
Assert.Equal("Hello", responseHeaders[HttpHeaderName].First());
}
public void WriteHeaders(
IReadOnlyList <IMetric> metrics,
bool includeDescription,
string[] timingAllowOrigins,
string expectedServerTiming,
string expectedTimingAllowOrigin = null)
{
var headerWriter = new HeaderWriter(timingAllowOrigins);
var headers = new HeaderDictionary();
headerWriter.WriteHeaders(headers, includeDescription, metrics);
headers[HeaderWriter.ServerTimingHeaderName].ToString().Should().Be(expectedServerTiming);
if (expectedTimingAllowOrigin == null)
{
headers.ContainsKey(HeaderWriter.TimingAllowOriginHeaderName).Should().BeFalse();
}
else
{
headers[HeaderWriter.TimingAllowOriginHeaderName].ToString().Should().Be(expectedTimingAllowOrigin);
}
}
public void OnActionExecuting_RequiredAndValidAndDoesNotHaveHeader_Returns400BadRequest()
{
var requestHeaders = new HeaderDictionary();
var responseHeaders = new HeaderDictionary();
this.httpContextMock.SetupGet(x => x.Request).Returns(this.httpRequestMock.Object);
this.httpContextMock.SetupGet(x => x.RequestServices).Returns(this.serviceProviderMock.Object);
this.httpRequestMock.SetupGet(x => x.Headers).Returns(requestHeaders);
this.serviceProviderMock.Setup(x => x.GetService(typeof(ILoggerFactory))).Returns(this.loggerFactoryMock.Object);
this.loggerFactoryMock.Setup(x => x.CreateLogger(typeof(HttpHeaderAttribute).FullName)).Returns(this.loggerMock.Object);
this.loggerMock.Setup(x => x.Log(LogLevel.Information, It.IsAny <EventId>(), It.IsAny <object>(), null, It.IsAny <Func <object, Exception, string> >()));
this.filter.Forward = true;
this.filter.Required = true;
this.filter.Valid = true;
this.filter.OnActionExecuting(this.actionExecutingContext);
Assert.False(responseHeaders.ContainsKey(HttpHeaderName));
Assert.IsType <BadRequestObjectResult>(this.actionExecutingContext.Result);
var badRequest = (BadRequestObjectResult)this.actionExecutingContext.Result;
Assert.Equal($"{HttpHeaderName} HTTP header is required.", badRequest.Value);
}
public bool ContainsKey(string key)
{
return(_headers.ContainsKey(key));
}
private ActionContext ArrangeActionContextMock(string httpMethod, HeaderDictionary requestHeaders, object requestBody, HeaderDictionary responseHeaders, IStatusCodeActionResult actionResult)
{
// Mock Post Request:
var request = new Mock <HttpRequest>();
request.Setup(r => r.Method).Returns(httpMethod);
// Mock Request's Headers (if any):
request.Setup(r => r.Headers).Returns(requestHeaders);
// Set the Content-Type based on the request headers.
string contentType = "json object";
if (requestHeaders.ContainsKey("Content-Type"))
{
contentType = requestHeaders["Content-Type"];
}
switch (requestBody)
{
case string requestBodyString:
if (!string.IsNullOrEmpty(requestBodyString))
{
request.SetupGet(r => r.Path).Returns("/resource");
request.SetupGet(r => r.QueryString).Returns(new QueryString());
request.SetupGet(c => c.ContentLength).Returns(requestBodyString.Length);
request.SetupGet(r => r.Body).Returns(new MemoryStream(Encoding.UTF8.GetBytes(requestBodyString)));
request.SetupGet(r => r.ContentType).Returns(contentType);
// The Form throws an exception when the Content-Type is not supported.
request.SetupGet(r => r.HasFormContentType).Returns(false);
request.SetupGet(r => r.Form).Throws(new InvalidOperationException($"Incorrect Content-Type: {contentType}"));
}
break;
// Mock Request's File:
case FormFile requestBodyFile:
if (requestBodyFile != null)
{
request.SetupGet(r => r.Path).Returns("/resource");
request.SetupGet(r => r.QueryString).Returns(new QueryString());
request.SetupGet(c => c.ContentLength).Returns(requestBodyFile.Length);
request.Setup(r => r.Form.Files).Returns(new FormFileCollection()
{
requestBodyFile
});
request.SetupGet(r => r.ContentType).Returns("multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW");
}
break;
}
// Mock Request's File:
//FormFile txtFile = new FormFile(new MemoryStream(Encoding.UTF8.GetBytes("This is a dummy file")), 0, 0, "Data", "dummy.txt");
//txtFile.Length
//request.Setup(r => r.Form.Files).Returns(new FormFileCollection() { txtFile });
// Mock HttpContext Request:
var httpContext = new Mock <HttpContext>();
httpContext.Setup(x => x.Request).Returns(request.Object);
// Mock HttpContext Response:
var httpResponse = new Mock <HttpResponse>();
httpResponse.Setup(r => r.Headers).Returns(responseHeaders);
if (actionResult != null)
{
httpResponse.SetupGet(c => c.StatusCode).Returns(actionResult.StatusCode.HasValue ? actionResult.StatusCode.Value : 500);
httpResponse.SetupGet(c => c.ContentLength).Returns(actionResult is ObjectResult ? ((ObjectResult)actionResult).Value.Serialize().Length : 0);
httpResponse.SetupGet(r => r.ContentType).Returns(contentType);
}
httpContext.SetupGet(c => c.Response).Returns(() => httpResponse.Object);
var actionContext = new ActionContext(
httpContext.Object,
Mock.Of <RouteData>(),
Mock.Of <ActionDescriptor>()
);
return(actionContext);
}
