public string GetStringCookies()
{
var cookies = ResponseCookies.GetCookies(_url);
var result = cookies.ToString();
return(result);
}
public void DeleteCookieWithDomainAndPathDeletesPriorMatchingCookies()
{
var headers = (IHeaderDictionary) new HeaderDictionary();
var features = MakeFeatures(headers);
var responseCookies = new ResponseCookies(features);
var testCookies = new (string Key, string Path, string Domain)[]
public void InvalidKeysThrow(string key)
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers);
Assert.Throws <ArgumentException>(() => cookies.Append(key, "1"));
}
public void DeleteCookieWithCookieOptionsShouldKeepPropertiesOfCookieOptions()
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers, null);
var testcookie = "TestCookie";
var time = new DateTimeOffset(2000, 1, 1, 1, 1, 1, 1, TimeSpan.Zero);
var options = new CookieOptions
{
Secure = true,
HttpOnly = true,
Path = "/",
Expires = time,
Domain = "example.com",
SameSite = SameSiteMode.Lax
};
cookies.Delete(testcookie, options);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Equal(1, cookieHeaderValues.Count);
Assert.StartsWith(testcookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
Assert.Contains("secure", cookieHeaderValues[0]);
Assert.Contains("httponly", cookieHeaderValues[0]);
Assert.Contains("samesite", cookieHeaderValues[0]);
}
private void CreateHttpServerInternal(int port)
{
_server = new HttpListener();
_server.Prefixes.Add($"http://127.0.0.1:{port}/");
_server.Prefixes.Add($"http://localhost:{port}/");
_server.Start();
while (_serverRunning)
{
HttpListenerContext context = _server.GetContext();
HttpListenerResponse response = context.Response;
byte[] buffer = Encoding.UTF8.GetBytes(ResponseBody);
if (ResponseCookies.Any())
{
response.AddCookiesRange(ResponseCookies);
}
if (ResponseHeader.Any())
{
response.AddHeaderRange(ResponseHeader);
}
response.ContentLength64 = buffer.Length;
Stream st = response.OutputStream;
st.Write(buffer, 0, buffer.Length);
context.Response.Close();
}
}
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);
}
internal HttpListenerResponse(HttpListenerContext context, System.Net.HttpListenerContext inner)
{
this.context = context;
this.inner = inner.Response;
this.Body = this.inner.OutputStream;
this.headers = new ResponseHeaderWrapper(inner);
this.cookies = new ResponseCookies(this.headers, pool.CreateStringBuilderPool());
}
public StubHttpResponse(StubHttpContext context)
{
HttpContext = context;
_feature = context.Features.Get <IHttpResponseFeature>();
Cookies = new ResponseCookies(Headers, new DefaultObjectPool <StringBuilder>(new DefaultPooledObjectPolicy <StringBuilder>()));
}
public void SetCookie(string name, object value)
{
if (value != null)
{
HttpCookie cookie = new HttpCookie(name, value.ToString());
cookie.Path = "/";
ResponseCookies.Add(cookie);
}
}
public void SetEncryptedCookie(string name, object value)
{
if (value != null)
{
HttpCookie cookie = new HttpCookie(name, CryptographyUtility.EncryptString(value));
cookie.Path = "/";
ResponseCookies.Add(cookie);
}
}
public void SetCookie(string name, object value, DateTime expiresTime)
{
if (value != null)
{
HttpCookie cookie = new HttpCookie(name, value.ToString());
cookie.Path = "/";
cookie.Expires = expiresTime;
ResponseCookies.Add(cookie);
}
}
public LocalHttpResponse(HttpContext httpContext)
{
HttpContext = httpContext;
Headers = new HeaderDictionary();
// ReSharper disable once VirtualMemberCallInConstructor
Cookies = new ResponseCookies(Headers, new DefaultObjectPool <StringBuilder>(new DefaultPooledObjectPolicy <StringBuilder>()));
Body = new MemoryStream();
HasStarted = false;
StatusCode = 200;
}
public void TestEmptyCookies()
{
ResponseCookies cookies = new ResponseCookies();
Assert.Equal(0, cookies.Count);
DateTime expires = DateTime.Now.AddDays(1);
cookies.Add(new ResponseCookie("myname", "myvalue", expires));
Assert.Equal(1, cookies.Count);
Assert.Equal("myvalue", cookies["myname"].Value);
Assert.Equal(expires, cookies["myname"].Expires);
}
public void EscapesValuesBeforeSettingCookie(string value, string expected)
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers);
cookies.Append("key", value);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Single(cookieHeaderValues);
Assert.StartsWith(expected, cookieHeaderValues[0]);
}
public void TestEmptyCookies()
{
ResponseCookies cookies = new ResponseCookies();
Assert.Equal(0, cookies.Count);
DateTime expires = DateTime.Now.AddDays(1);
cookies.Add(new ResponseCookie("myname", "myvalue", expires));
Assert.Equal(1, cookies.Count);
Assert.Equal("myvalue", cookies["myname"].Value);
Assert.Equal(expires, cookies["myname"].Expires);
}
public void AppContextSwitchEscapesKeysAndValuesBeforeSettingCookie(string key, string value, string expected)
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers);
cookies._enableCookieNameEncoding = true;
cookies.Append(key, value);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Single(cookieHeaderValues);
Assert.StartsWith(expected, cookieHeaderValues[0]);
}
public void DeleteCookieShouldSetDefaultPath()
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers, null);
var testcookie = "TestCookie";
cookies.Delete(testcookie);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Equal(1, cookieHeaderValues.Count);
Assert.StartsWith(testcookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
}
public void EscapesKeyValuesBeforeSettingCookie(
string key,
string value,
string expected)
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers, null);
cookies.Append(key, value);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Equal(1, cookieHeaderValues.Count);
Assert.StartsWith(expected, cookieHeaderValues[0]);
}
public StubHttpResponse(StubHttpContext context)
{
HttpContext = context;
_httpResponseFeature = context.Features.Get <IHttpResponseFeature>();
#if NETCOREAPP3_0
Cookies = new StubResponseCookieCollection();
_features = context.Features;
_features.Set <IHttpResponseBodyFeature>(new StreamResponseBodyFeature(new MemoryStream()));
#else
Cookies =
new ResponseCookies(Headers, new DefaultObjectPool <StringBuilder>(new DefaultPooledObjectPolicy <StringBuilder>()));
#endif
}
public async System.Threading.Tasks.Task ConnectAndEstabilishSession(Uri connectionUri)
{
try
{
HttpResponseMessage response = await Client.PostAsync(connectionUri, this.Content);
this.ResponseCookies = CookieContainer.GetCookies(connectionUri).Cast <Cookie>();
this.SessionCookie = ResponseCookies.ElementAt(0);
}
catch
{
throw new System.Net.Http.HttpRequestException(
"Printer is not reachable " + connectionUri);
}
}
public void NoParamsDeleteRemovesCookieCreatedByAdd()
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers, null);
var testcookie = "TestCookie";
cookies.Append(testcookie, testcookie);
cookies.Delete(testcookie);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Equal(1, cookieHeaderValues.Count);
Assert.StartsWith(testcookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
}
public void DeleteCookieShouldSetDefaultPath()
{
var headers = (IHeaderDictionary) new HeaderDictionary();
var features = MakeFeatures(headers);
var cookies = new ResponseCookies(features);
var testCookie = "TestCookie";
cookies.Delete(testCookie);
var cookieHeaderValues = headers.SetCookie;
Assert.Single(cookieHeaderValues);
Assert.StartsWith(testCookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
}
public async Task <string> UploadStringTaskAsync(string data)
{
var request = (HttpWebRequest)WebRequest.Create(_url);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.CookieContainer = RequestCookies ?? new CookieContainer();
if (Headers.ContainsKey("Accept"))
{
request.Accept = Headers["Accept"];
Headers.Remove("Accept");
}
if (Headers.ContainsKey("User-Agent"))
{
request.UserAgent = Headers["User-Agent"];
Headers.Remove("User-Agent");
}
if (Headers.ContainsKey("Connection"))
{
request.Connection = Headers["Connection"];
Headers.Remove("Connection");
}
foreach (var item in Headers)
{
request.Headers.Add(item.Key, item.Value);
}
byte[] byteArray = Encoding.UTF8.GetBytes(data);
request.ContentLength = byteArray.Length;
var requestStrem = await request.GetRequestStreamAsync();
requestStrem.Write(byteArray, 0, byteArray.Length);
requestStrem.Close();
var response = (HttpWebResponse)await request.GetResponseAsync();
foreach (Cookie item in response.Cookies)
{
ResponseCookies.Add(item);
}
var responseStream = response.GetResponseStream();
StreamReader reader = new StreamReader(responseStream, Encoding.UTF8);
var result = await reader.ReadToEndAsync();
return(result);
}
public void ProvidesMaxAgeWithCookieOptionsArgumentExpectMaxAgeToBeSet()
{
var headers = new HeaderDictionary();
var cookies = new ResponseCookies(headers, null);
var cookieOptions = new CookieOptions();
var maxAgeTime = TimeSpan.FromHours(1);
cookieOptions.MaxAge = TimeSpan.FromHours(1);
var testcookie = "TestCookie";
cookies.Append(testcookie, testcookie, cookieOptions);
var cookieHeaderValues = headers[HeaderNames.SetCookie];
Assert.Equal(1, cookieHeaderValues.Count);
Assert.Contains($"max-age={maxAgeTime.TotalSeconds.ToString()}", cookieHeaderValues[0]);
}
public void NoParamsDeleteRemovesCookieCreatedByAdd()
{
var headers = (IHeaderDictionary) new HeaderDictionary();
var features = MakeFeatures(headers);
var cookies = new ResponseCookies(features);
var testCookie = "TestCookie";
cookies.Append(testCookie, testCookie);
cookies.Delete(testCookie);
var cookieHeaderValues = headers.SetCookie;
Assert.Single(cookieHeaderValues);
Assert.StartsWith(testCookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
}
public void ProvidesMaxAgeWithCookieOptionsArgumentExpectMaxAgeToBeSet()
{
var headers = (IHeaderDictionary) new HeaderDictionary();
var features = MakeFeatures(headers);
var cookies = new ResponseCookies(features);
var cookieOptions = new CookieOptions();
var maxAgeTime = TimeSpan.FromHours(1);
cookieOptions.MaxAge = TimeSpan.FromHours(1);
var testCookie = "TestCookie";
cookies.Append(testCookie, testCookie, cookieOptions);
var cookieHeaderValues = headers.SetCookie;
Assert.Single(cookieHeaderValues);
Assert.Contains($"max-age={maxAgeTime.TotalSeconds}", cookieHeaderValues[0]);
}
public async Task <string> DownloadStringTaskAsync()
{
var request = (HttpWebRequest)WebRequest.Create(_url);
foreach (var item in Headers)
{
request.Headers.Add(item.Key, item.Value);
}
request.Method = "GET";
request.CookieContainer = RequestCookies ?? new CookieContainer();
var response = (HttpWebResponse)await request.GetResponseAsync();
foreach (Cookie item in response.Cookies)
{
ResponseCookies.Add(item);
}
using var dataStream = response.GetResponseStream();
using var reader = new StreamReader(dataStream);
return(await reader.ReadToEndAsync());
}
public void AppendWithExtensions()
{
var headers = (IHeaderDictionary) new HeaderDictionary();
var features = MakeFeatures(headers);
var cookies = new ResponseCookies(features);
var testCookie = "TestCookie";
cookies.Append(testCookie, "value", new CookieOptions()
{
Extensions = { "simple", "key=value" }
});
var cookieHeaderValues = headers.SetCookie;
Assert.Single(cookieHeaderValues);
Assert.StartsWith(testCookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("simple;", cookieHeaderValues[0]);
Assert.EndsWith("key=value", cookieHeaderValues[0]);
}
public void DeleteWithExtensions()
{
var headers = (IHeaderDictionary) new HeaderDictionary();
var features = MakeFeatures(headers);
var cookies = new ResponseCookies(features);
var testCookie = "TestCookie";
cookies.Delete(testCookie, new CookieOptions()
{
Extensions = { "simple", "key=value" }
});
var cookieHeaderValues = headers.SetCookie;
Assert.Single(cookieHeaderValues);
Assert.StartsWith(testCookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("expires=Thu, 01 Jan 1970 00:00:00 GMT", cookieHeaderValues[0]);
Assert.Contains("simple;", cookieHeaderValues[0]);
Assert.EndsWith("key=value", cookieHeaderValues[0]);
}
public void AppendSameSiteNoneWithoutSecureLogsWarning()
{
var headers = (IHeaderDictionary) new HeaderDictionary();
var features = MakeFeatures(headers);
var services = new ServiceCollection();
var sink = new TestSink(TestSink.EnableWithTypeName <ResponseCookies>);
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
services.AddLogging();
services.AddSingleton <ILoggerFactory>(loggerFactory);
features.Set <IServiceProvidersFeature>(new ServiceProvidersFeature()
{
RequestServices = services.BuildServiceProvider()
});
var cookies = new ResponseCookies(features);
var testCookie = "TestCookie";
cookies.Append(testCookie, "value", new CookieOptions()
{
SameSite = SameSiteMode.None,
});
var cookieHeaderValues = headers.SetCookie;
Assert.Single(cookieHeaderValues);
Assert.StartsWith(testCookie, cookieHeaderValues[0]);
Assert.Contains("path=/", cookieHeaderValues[0]);
Assert.Contains("samesite=none", cookieHeaderValues[0]);
Assert.DoesNotContain("secure", cookieHeaderValues[0]);
var writeContext = Assert.Single(sink.Writes);
Assert.Equal("The cookie 'TestCookie' has set 'SameSite=None' and must also set 'Secure'.", writeContext.Message);
}
public StubHttpResponse(StubHttpContext context)
{
HttpContext = context;
Cookies = new ResponseCookies(Headers, new DefaultObjectPool <StringBuilder>(new DefaultPooledObjectPolicy <StringBuilder>()));
}
