public void GetUserSessionFromCookieReturnsSessionWhenCookieExists()
{
// Arrange
var userSession = new DfcUserSession
{
SessionId = "DummySessionId",
Salt = "DummySalt",
CreatedDate = DateTime.UtcNow,
PartitionKey = "DummyPartitionKey",
};
var userSessionJson = JsonConvert.SerializeObject(userSession);
var httpContext = A.Fake <HttpContext>();
var localHttpContextAccessor = new HttpContextAccessor {
HttpContext = httpContext
};
var cookies = new RequestCookieCollection(new Dictionary <string, string> {
{ SessionName, userSessionJson }
});
A.CallTo(() => localHttpContextAccessor.HttpContext.Request.Cookies).Returns(cookies);
var localSessionClient = new SessionClient(sessionIdGenerator, partitionKeyGenerator, localHttpContextAccessor, config, logger);
// Act
var result = localSessionClient.GetUserSessionFromCookie();
// Assert
Assert.Equal(userSession.GetCookieSessionId, result.GetCookieSessionId);
}
public FakeRequestCookies()
{
Cookies = new RequestCookieCollection(new Dictionary <string, string>
{
{ "auth_token", Guid.NewGuid().ToString() }
});
}
public void Then_The_Cookie_Is_Deleted_If_Exists(
string testCookieName,
string content,
Mock <IDataProtectionProvider> provider)
{
var featureMock = new Mock <IRequestCookiesFeature>();
var responseCookiesFeature = new Mock <IResponseCookiesFeature>();
var cookieDictionary = new RequestCookieCollection(new Dictionary <string, string> {
{ testCookieName, Convert.ToBase64String(Encoding.UTF8.GetBytes(content)) }
});
var mockHeaderDictionary = new HeaderDictionary();
var mockResponseHeaderDictionary = new ResponseCookies(mockHeaderDictionary, Mock.Of <ObjectPool <StringBuilder> >());
featureMock.Setup(x => x.Cookies).Returns(cookieDictionary);
responseCookiesFeature.Setup(x => x.Cookies).Returns(mockResponseHeaderDictionary);
var responseMock = new FeatureCollection();
responseMock.Set(featureMock.Object);
responseMock.Set(responseCookiesFeature.Object);
var context = new DefaultHttpContext(responseMock);
var mockHttpContextAccessor = new Mock <IHttpContextAccessor>();
mockHttpContextAccessor.Setup(_ => _.HttpContext).Returns(context);
var service = new CookieStorageService <string>(mockHttpContextAccessor.Object, provider.Object);
//Act
service.Delete(testCookieName);
//Assert
var actual = mockHeaderDictionary["set-cookie"].ToArray().First().Split(";");
var actualExpiry = DateTime.Parse(actual.Skip(1).First().Split("=").Last());
Assert.IsTrue(actualExpiry < DateTime.UtcNow);
}
private static IList <RaygunRequestMessage.Cookie> GetCookies(RequestCookieCollection cookies)
{
// ToDo: filter cookies
return(cookies
.Select(c => new RaygunRequestMessage.Cookie(c.Key, c.Value))
.ToList());
}
public async Task MyMiddleware_Should_Set_RequestHeader_And_ResponseHeader()
{
//Arrange
var cookieStore = new Dictionary <string, string> {
{ "cookie-name", "cookie-value" }
};
var cookies = new RequestCookieCollection(cookieStore);
var request = Mock.Of <IOwinRequest>();
var requestMock = Mock.Get(request);
requestMock.Setup(_ => _.Cookies).Returns(cookies);
requestMock.Setup(_ => _.User.Identity.IsAuthenticated).Returns(true);
requestMock.Setup(_ => _.Headers.Append(It.IsAny <string>(), It.IsAny <string>()));
var response = new OwinResponse();
var context = Mock.Of <OwinContext>();
var contextMock = Mock.Get(context);
contextMock.CallBase = true;
contextMock.Setup(_ => _.Request).Returns(request);
contextMock.Setup(_ => _.Response).Returns(response);
RequestDelegate next = _ => Task.FromResult((object)null);
var myMiddleware = new MyMiddleware(next);
//Act
await myMiddleware.Invoke(context);
//Assert
requestMock.Verify(_ => _.Headers.Append("header-name", "header-value"));
response.Headers.ContainsKey("Set-Cookie");
}
public void Then_The_Cookie_Data_Is_Retrieved(
string testCookieName,
string content)
{
//Arrange
var mockDataProtector = new Mock <IDataProtector>();
mockDataProtector.Setup(sut => sut.Unprotect(It.IsAny <byte[]>())).Returns(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(content)));
var mockDataProtectionProvider = new Mock <IDataProtectionProvider>();
mockDataProtectionProvider.Setup(s => s.CreateProtector(It.IsAny <string>())).Returns(mockDataProtector.Object);
var featureMock = new Mock <IRequestCookiesFeature>();
var mockHeaderDictionary = new RequestCookieCollection(new Dictionary <string, string> {
{ testCookieName, Convert.ToBase64String(Encoding.UTF8.GetBytes(content)) }
});
featureMock.Setup(x => x.Cookies).Returns(mockHeaderDictionary);
var responseMock = new FeatureCollection();
responseMock.Set(featureMock.Object);
var context = new DefaultHttpContext(responseMock);
var mockHttpContextAccessor = new Mock <IHttpContextAccessor>();
mockHttpContextAccessor.Setup(_ => _.HttpContext).Returns(context);
var service = new CookieStorageService <string>(mockHttpContextAccessor.Object, mockDataProtectionProvider.Object);
//Act
var actual = service.Get(testCookieName);
//Assert
actual.Should().NotBeNull();
actual.Should().Be(content);
}
public void SingleCookie()
{
var subject = new RequestCookieCollection("name=value");
subject.Get("name").Value.Should().Be("value");
subject.Count().Should().Be(1);
}
public void TrailingSeparator()
{
var subject = new RequestCookieCollection("name=value;");
subject.Get("name").Value.Should().Be("value");
subject.Count().Should().Be(1);
}
public async void SelectorResultNullWhenNoQueryParameterOrCookie()
{
// Arrange
var queryCollection = new QueryCollection(); // No Query Parameter
var requestCookieCollection = new RequestCookieCollection(); // No Cookie
var responseCookies = new ResponseCookies();
var mockContext = new Mock <HttpContext>();
mockContext.Setup(p => p.User.IsInRole(SwitcherooThemeSelector.RequiredRole)).Returns(true);
mockContext.SetupGet(p => p.Request.Query).Returns(queryCollection);
mockContext.SetupGet(p => p.Request.Cookies).Returns(requestCookieCollection);
mockContext.SetupGet(p => p.Response.Cookies).Returns(responseCookies);
var mockContextAccessor = new Mock <IHttpContextAccessor>();
mockContextAccessor.SetupGet(p => p.HttpContext).Returns(mockContext.Object);
var mockThemeService = new Mock <ISiteThemeService>();
mockThemeService.Setup(p => p.GetCurrentThemeNameAsync()).ReturnsAsync(CurrentActiveTheme);
IThemeSelector selector = new SwitcherooThemeSelector(mockThemeService.Object, mockContextAccessor.Object);
// Act
var result = await selector.GetThemeAsync();
// Assert
Assert.Null(result);
Assert.Empty(responseCookies.Cookies);
}
public async Task TryFindSessionCodeUsesQueryDataWhenOnlyQueryStringAndCookieSourcesExist()
{
// Arrange
const string expectedQueryStringValue = "qsValue";
var userSession = new DfcUserSession
{
SessionId = "DummySessionId",
Salt = "DummySalt",
CreatedDate = DateTime.UtcNow,
PartitionKey = "DummyPartitionKey",
};
var userSessionJson = JsonConvert.SerializeObject(userSession);
var httpContext = A.Fake <HttpContext>();
var dummyQueryString = new QueryString($"?{SessionName.TrimStart('.')}={expectedQueryStringValue}");
var cookies = new RequestCookieCollection(new Dictionary <string, string> {
{ SessionName, userSessionJson }
});
var localHttpContextAccessor = new HttpContextAccessor {
HttpContext = httpContext
};
A.CallTo(() => localHttpContextAccessor.HttpContext.Request.Cookies).Returns(cookies);
A.CallTo(() => localHttpContextAccessor.HttpContext.Request.QueryString).Returns(dummyQueryString);
var localSessionClient = new SessionClient(sessionIdGenerator, partitionKeyGenerator, localHttpContextAccessor, config, logger);
// Act
var result = await localSessionClient.TryFindSessionCode().ConfigureAwait(false);
// Assert
Assert.Equal(expectedQueryStringValue, result);
}
/// <summary>
/// Parse a header
/// </summary>
/// <param name="name">Name of header.</param>
/// <param name="reader">Reader containing value.</param>
/// <returns>HTTP Header</returns>
/// <exception cref="FormatException">Header value is not of the expected format.</exception>
public IHeader Parse(string name, ITextReader reader)
{
//key: "value"; key: "value"
var cookies = new RequestCookieCollection();
while (!reader.EOF)
{
// read name
string cookieName = reader.ReadToEnd("=;");
// cookie with value?
if (reader.Current == '=')
{
reader.Consume();
reader.ConsumeWhiteSpaces();
// is value quoted or not?
string value = reader.Current == '"' ? reader.ReadQuotedString() : reader.ReadToEnd(";");
cookies.Add(new RequestCookie(cookieName, value));
}
//else
// cookies.Add(new RequestCookie(cookieName, string.Empty));
// consume whitespaces and cookie separator
reader.ConsumeWhiteSpaces(';');
}
return(new CookieHeader(cookies));
}
/// <summary>
/// Parse a header
/// </summary>
/// <param name="name">Name of header.</param>
/// <param name="reader">Reader containing value.</param>
/// <returns>HTTP Header</returns>
/// <exception cref="FormatException">Header value is not of the expected format.</exception>
public IHeader Parse(string name, ITextReader reader)
{
//key: "value"; key: "value"
var cookies = new RequestCookieCollection();
while (!reader.EOF)
{
// read name
string cookieName = reader.ReadToEnd("=;");
// cookie with value?
if (reader.Current == '=')
{
reader.Consume();
reader.ConsumeWhiteSpaces();
// is value quoted or not?
string value = reader.Current == '"' ? reader.ReadQuotedString() : reader.ReadToEnd(";");
cookies.Add(new RequestCookie(cookieName, value));
}
// consume whitespaces and cookie separator
reader.ConsumeWhiteSpaces(';');
}
return new CookieHeader(cookies);
}
public void LoadTempData_Base64UrlDecodesAnd_UnprotectsData_FromCookie()
{
// Arrange
var expectedValues = new Dictionary <string, object>();
expectedValues.Add("int", 10);
var tempDataProviderSerializer = new TempDataSerializer();
var expectedDataToUnprotect = tempDataProviderSerializer.Serialize(expectedValues);
var base64AndUrlEncodedDataInCookie = WebEncoders.Base64UrlEncode(expectedDataToUnprotect);
var dataProtector = new PassThroughDataProtector();
var tempDataProvider = GetProvider(dataProtector);
var requestCookies = new RequestCookieCollection(new Dictionary <string, string>()
{
{ CookieTempDataProvider.CookieName, base64AndUrlEncodedDataInCookie }
});
var httpContext = new Mock <HttpContext>();
httpContext
.Setup(hc => hc.Request.Cookies)
.Returns(requestCookies);
// Act
var actualValues = tempDataProvider.LoadTempData(httpContext.Object);
// Assert
Assert.Equal(expectedDataToUnprotect, dataProtector.DataToUnprotect);
Assert.Equal(expectedValues, actualValues);
}
public RequestCookiesFeatureStub()
{
Cookies = new RequestCookieCollection(new Dictionary <string, string>
{
{ "x_x", "programmingisbullshit" }
});
}
public void AppContextSwitchUnEscapesKeysAndValues(string input, string expectedKey, string expectedValue)
{
var cookies = RequestCookieCollection.ParseInternal(new StringValues(input), enableCookieNameEncoding: true);
Assert.Equal(1, cookies.Count);
Assert.Equal(expectedKey, cookies.Keys.Single());
Assert.Equal(expectedValue, cookies[expectedKey]);
}
public void UnEscapesValues(string input, string expectedKey, string expectedValue)
{
var cookies = RequestCookieCollection.Parse(new StringValues(input));
Assert.Equal(1, cookies.Count);
Assert.Equal(expectedKey, cookies.Keys.Single());
Assert.Equal(expectedValue, cookies[expectedKey]);
}
public void CommaSeparated()
{
var subject = new RequestCookieCollection("name=value,name2=value2");
subject.Get("name").Value.ShouldEqual("value");
subject.Get("name2").Value.ShouldEqual("value2");
subject.Count().ShouldEqual(2);
}
public void Base64Value()
{
var cookieValue = "WC4YUK+AAr3CTkapr3SMoiijXl/8H0Ik5vSNyJFemRjihUJZcQ6VbugPfw81HGAOhteaVTEDEGpovCLDL6mnLJlvZheJKHMxkGiYTDqAY3UHfdIJc3H+pmby5diysgBth/kOWVi9dnDx0tTv7dsnt0psbFG2o/iu93vOiIJshqkRcUCwo2cWjtU80gO1zkhnPzgelj4K85do7GI17oZFrSimROIFHTXM";
var subject = new RequestCookieCollection($"name={cookieValue}");
subject.Get("name").Value.Should().Be(cookieValue);
}
/// <summary>
/// Initializes a new instance of the <see cref="CookieHeader"/> class.
/// </summary>
/// <param name="collection">The collection.</param>
/// <exception cref="ArgumentNullException"><c>collection</c> is <c>null</c>.</exception>
public CookieHeader(RequestCookieCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
Cookies = collection;
}
public void CommaInValue()
{
var subject = new RequestCookieCollection("name=value,value2");
subject.Get("name").Value.Should().Be("value");
subject.Get("value2").Value.Should().Be("");
subject.Count().Should().Be(2);
}
public void TwoCookies()
{
var subject = new RequestCookieCollection("name=value;name2=value2");
subject.Get("name").Value.Should().Be("value");
subject.Get("name2").Value.Should().Be("value2");
subject.Count().Should().Be(2);
}
public void Whitespace()
{
var subject = new RequestCookieCollection("name=value\n;\tname2=value2 ; name3=value3\n");
subject.Get("name").Value.Should().Be("value");
subject.Get("name2").Value.Should().Be("value2");
subject.Get("name3").Value.Should().Be("value3");
subject.Count().Should().Be(3);
}
private HttpContext GetHttpContext(string cookieName, string cookieValue)
{
var cookies = new RequestCookieCollection(new Dictionary <string, string>
{
{ cookieName, cookieValue },
});
return(GetHttpContext(cookies));
}
/// <summary>
/// Redirect user to import page with current job opened
/// </summary>
/// <param name="context">Current OWin Context</param>
/// <param name="encodedUrl">Encoded Url to be redirected </param>
/// <returns>Redirects to specified page</returns>
public static string GetOAuthUrl(IOwinContext context, string encodedUrl)
{
string decodedUrl = HttpUtility.UrlDecode(encodedUrl);
RequestCookieCollection cookies = context.Request.Cookies;
string jobId = cookies["jobId"];
string stateToken = CreateAndSetStateCookie(context);
return(string.Format("{0}&state={1}&jobId={2}", decodedUrl, stateToken, jobId));
}
public void MixedSeparated()
{
var subject = new RequestCookieCollection("name=value,name2=value2;name3=value3");
subject.Get("name").Value.Should().Be("value");
subject.Get("name2").Value.Should().Be("value2");
subject.Get("name3").Value.Should().Be("value3");
subject.Count().Should().Be(3);
}
public MockHttpRequest() : base()
{
Form = new FormCollection(new Dictionary <string, StringValues>());
headers = new HeaderDictionary();
Cookies = new RequestCookieCollection();
Method = "GET";
Body = new MemoryStream();
ContentLength = 0;
}
public MockHttpCookieAccess(string cookieName = null, string cookieContent = null)
{
if (cookieName != null)
{
_requestCookies[cookieName] = cookieContent;
}
CookiesIn = new RequestCookieCollection(_requestCookies);
CookiesOut = new ResponseCookies(HeaderDict, null);
}
public bool Login2(string uname, string upwd, RequestCookieCollection cookieCollection)
{
string loginUrl = "http://www.bjguahao.gov.cn/quicklogin.htm";
Dictionary <string, string> cc = new Dictionary <string, string>();
cc.Add("1", "1");
cc.Add("2", "2");
cookieCollection = new RequestCookieCollection(cc);
return(true);
}
public override Task Invoke(IOwinContext context)
{
RequestCookieCollection cool = context.Request.Cookies;
if ((cool["Auth"] == null) && (context.Request.Path.ToString().EndsWith("ecret")))
{
return(context.Response.WriteAsync("<h1>Hey!!</h1>"));
}
return(Next.Invoke(context));
}
public HttpCookieCollection(RequestCookieCollection cookies, HttpContextSettings settings)
: base(cookie => cookie.Name)
{
var str = string.Format("/{0}/", settings.SecureCookiePrefix);
cookies.Where(cookie => !cookie.Value.StartsWith(str, StringComparison.Ordinal))
.Select(x => new HttpCookie(x.Key, x.Value))
.ToList()
.ForEach(this.Add);
}
public static Task InvokeRequest(IOwinContext context)
{
RequestCookieCollection cookies = context.Request.Cookies;
string owinCookieValue = cookies["OwinCookieKey"];
IReadableStringCollection stringquery = context.Request.Query;
string owinquery = stringquery["owin"];
context.Response.ContentType = "text/plain";
return(context.Response.WriteAsync("Hello World 2"));
}
public HttpListenerRequestWrapper(HttpListenerRequest httpListenerRequest)
{
_httpListenerRequest = httpListenerRequest;
_qs = new NameValueCollection(httpListenerRequest.QueryString);
_headers = new NameValueCollection(httpListenerRequest.Headers);
_cookies = new RequestCookieCollection(httpListenerRequest.Cookies.Cast<System.Net.Cookie>()
.Select(c => new SignalR.Hosting.Cookie (
name: c.Name,
value: c.Value,
domain: c.Domain,
path: c.Path
)));
}
public AspNetRequest(HttpRequestBase request)
{
_request = request;
Cookies = new RequestCookieCollection(request.Cookies.Cast<string>()
.Select(key =>
{
var cookie = request.Cookies[key];
return new Cookie (
name: cookie.Name,
value: cookie.Value,
domain: cookie.Domain,
path: cookie.Path
);
}));
ResolveFormAndQueryString();
}
public Request(Uri uri, Action abort, Dictionary<string, string> postData, IPrincipal user)
{
Url = uri;
_abort = abort;
User = user;
Form = new NameValueCollection();
Headers = new NameValueCollection();
ServerVariables = new NameValueCollection();
QueryString = HttpUtility.ParseDelimited(Url.Query.TrimStart('?'));
Cookies = new RequestCookieCollection();
if (postData != null)
{
foreach (var pair in postData)
{
Form[pair.Key] = pair.Value;
}
}
}
public OwinRequest(IDictionary<string, object> environment, string body)
{
var env = new Gate.Environment(environment);
var headers = env.Headers;
Url = BuildUrl(env);
Headers = new NameValueCollection();
foreach (var pair in headers)
{
foreach (var value in pair.Value)
{
Headers.Add(pair.Key, value);
}
}
// TODO: Add a cookie source that parses the cookie header
Cookies = new RequestCookieCollection(new Cookie[0]);
QueryString = ParseDelimited(env.QueryString);
Form = ParseDelimited(body);
}
/// <summary>
/// Parse a header
/// </summary>
/// <param name="name">Name of header.</param>
/// <param name="reader">Reader containing value.</param>
/// <returns>HTTP Header</returns>
/// <exception cref="System.FormatException">Header value is not of the expected format.</exception>
public IHeader Create(string name, ITextReader reader)
{
if (reader == null) return null;
var cookies = new RequestCookieCollection();
while (!reader.Eof)
{
string cookieName = reader.ReadToEnd("=;");
if (reader.Current == '=')
{
reader.Consume();
reader.ConsumeWhiteSpaces();
string value = reader.Current == '"' ? reader.ReadQuotedString() : reader.ReadToEnd(";");
cookies.Add(cookieName, new RequestCookie(cookieName, value));
}
reader.ConsumeWhiteSpaces(';');
}
return new CookieHeader(cookies);
}
private HttpContext GetHttpContext(string cookieName, string cookieValue)
{
var cookies = new RequestCookieCollection(new Dictionary<string, string>
{
{ cookieName, cookieValue },
});
return GetHttpContext(cookies);
}
public void WithHttpRequestShouldWorkCorrectlyWithDefaultValues()
{
var stream = new MemoryStream();
var requestCookies = new RequestCookieCollection(
new Dictionary<string, string>
{
{ "MyRequestCookie", "MyRequestCookieValue" },
{ "AnotherRequestCookie", "AnotherRequestCookieValue" }
});
var files = new[]
{
new FormFile(stream, 0, 0, "FirstFile", "FirstFileName"),
new FormFile(stream, 0, 0, "SecondFile", "SecondFileName"),
};
MyController<MvcController>
.Instance()
.WithHttpRequest(request => request
.WithBody(stream)
.WithContentLength(1)
.WithContentType(ContentType.ApplicationJson)
.AndAlso()
.WithCookie("MyCookie", "MyCookieValue")
.WithCookies(new Dictionary<string, string>
{
{ "MyDictCookie", "MyDictCookieValue" },
{ "AnotherDictCookie", "AnotherDictCookieValue" }
})
.WithCookies(requestCookies)
.WithCookies(new
{
ObjectCookie = "ObjectCookieValue",
AnotherObjectCookie = "AnotherObjectCookieValue"
})
.AndAlso()
.WithFormField("Field", "FieldValue")
.WithFormField("MultiField", "FirstFieldValue", "SecondFieldValue")
.WithFormFields(new Dictionary<string, IEnumerable<string>>
{
{ "MyDictField", new[] { "MyDictFieldValue" } },
{ "AnotherDictField", new[] { "AnotherDictFieldValue" } }
})
.AndAlso()
.WithFormFiles(files)
.AndAlso()
.WithHeader("MyHeader", "MyHeaderValue")
.WithHeader("MultiHeader", "FirstHeaderValue", "SecondHeaderValue")
.WithHeaders(new Dictionary<string, IEnumerable<string>>
{
{ "MyDictHeader", new[] { "MyDictHeaderValue" } },
{ "AnotherDictHeader", new[] { "AnotherDictHeaderValue" } }
})
.AndAlso()
.WithHost("mytestedasp.net")
.WithMethod("POST")
.WithPath("/all")
.WithPathBase("/api")
.WithProtocol("protocol")
.WithQueryString("?key=value&another=yetanother")
.WithHttps())
.ShouldPassForThe<HttpRequest>(builtRequest =>
{
Assert.Same(stream, builtRequest.Body);
Assert.Equal(1, builtRequest.ContentLength);
Assert.Same(ContentType.ApplicationJson, builtRequest.ContentType);
Assert.Equal(7, builtRequest.Cookies.Count);
Assert.Equal("MyCookieValue", builtRequest.Cookies["MyCookie"]);
Assert.Equal("MyDictCookieValue", builtRequest.Cookies["MyDictCookie"]);
Assert.Equal("AnotherDictCookieValue", builtRequest.Cookies["AnotherDictCookie"]);
Assert.Equal("MyRequestCookieValue", builtRequest.Cookies["MyRequestCookie"]);
Assert.Equal("AnotherRequestCookieValue", builtRequest.Cookies["AnotherRequestCookie"]);
Assert.Equal("ObjectCookieValue", builtRequest.Cookies["ObjectCookie"]);
Assert.Equal("AnotherObjectCookieValue", builtRequest.Cookies["AnotherObjectCookie"]);
Assert.Equal(4, builtRequest.Form.Count);
Assert.Equal("FieldValue", builtRequest.Form["Field"]);
Assert.Equal("FirstFieldValue,SecondFieldValue", builtRequest.Form["MultiField"]);
Assert.Equal("MyDictFieldValue", builtRequest.Form["MyDictField"]);
Assert.Equal("AnotherDictFieldValue", builtRequest.Form["AnotherDictField"]);
Assert.Equal(2, builtRequest.Form.Files.Count);
Assert.Same(files[0], builtRequest.Form.Files[0]);
Assert.Same(files[1], builtRequest.Form.Files[1]);
Assert.Equal(8, builtRequest.Headers.Count);
Assert.Equal("MyHeaderValue", builtRequest.Headers["MyHeader"]);
Assert.Equal("FirstHeaderValue,SecondHeaderValue", builtRequest.Headers["MultiHeader"]);
Assert.Equal("MyDictHeaderValue", builtRequest.Headers["MyDictHeader"]);
Assert.Equal("AnotherDictHeaderValue", builtRequest.Headers["AnotherDictHeader"]);
Assert.Equal("mytestedasp.net", builtRequest.Host.Value);
Assert.Equal("POST", builtRequest.Method);
Assert.Equal("/all", builtRequest.Path);
Assert.Equal("/api", builtRequest.PathBase);
Assert.Equal("protocol", builtRequest.Protocol);
Assert.Equal("?key=value&another=yetanother", builtRequest.QueryString.Value);
Assert.Equal("https", builtRequest.Scheme);
Assert.Equal(2, builtRequest.Query.Count);
Assert.Equal("value", builtRequest.Query["key"]);
Assert.Equal("yetanother", builtRequest.Query["another"]);
});
}
public RequestOptions()
{
Headers = new RequestHeaders();
Cookies = new RequestCookieCollection(Headers);
}
public void Cookies_GetAndSet()
{
var request = new DefaultHttpContext().Request;
var cookieHeaders = request.Headers["Cookie"];
Assert.Equal(0, cookieHeaders.Count);
var cookies0 = request.Cookies;
Assert.Equal(0, cookies0.Count);
Assert.Null(cookies0["key0"]);
Assert.False(cookies0.ContainsKey("key0"));
var newCookies = new[] { "name0=value0", "name1=value1" };
request.Headers["Cookie"] = newCookies;
cookies0 = RequestCookieCollection.Parse(newCookies);
var cookies1 = request.Cookies;
Assert.Equal(cookies0, cookies1);
Assert.Equal(2, cookies1.Count);
Assert.Equal("value0", cookies1["name0"]);
Assert.Equal("value1", cookies1["name1"]);
Assert.Equal(newCookies, request.Headers["Cookie"]);
var cookies2 = new RequestCookieCollection(new Dictionary<string,string>()
{
{ "name2", "value2" }
});
request.Cookies = cookies2;
Assert.Equal(cookies2, request.Cookies);
Assert.Equal("value2", request.Cookies["name2"]);
cookieHeaders = request.Headers["Cookie"];
Assert.Equal(new[] { "name2=value2" }, cookieHeaders);
}
/// <summary>
/// Initializes a new instance of the <see cref="CookieHeader"/> class.
/// </summary>
/// <param name="collection">The collection.</param>
/// <exception cref="ArgumentNullException"><c>collection</c> is <c>null</c>.</exception>
public CookieHeader(RequestCookieCollection collection)
{
if (collection == null)
throw new ArgumentNullException("collection");
Cookies = collection;
}
public OwinRequestCookieCollection(RequestCookieCollection cookies) {
_cookies = cookies;
}
