public void UpdateComparisonListCookieAddsDefaultSchoolToTheListByDefault()
{
var request = new Mock <HttpRequestBase>(MockBehavior.Strict);
var response = new Mock <HttpResponseBase>(MockBehavior.Strict);
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
context.SetupGet(x => x.Request).Returns(request.Object);
context.SetupGet(x => x.Response).Returns(response.Object);
var requestCookies = new HttpCookieCollection();
var listCookie = new ComparisonListModel();
listCookie.BenchmarkSchools = new List <BenchmarkSchoolViewModel>();
requestCookies.Add(new HttpCookie(CookieNames.COMPARISON_LIST, JsonConvert.SerializeObject(listCookie)));
context.SetupGet(x => x.Request.Cookies).Returns(requestCookies);
context.SetupGet(x => x.Response.Cookies).Returns(requestCookies);
var rc = new RequestContext(context.Object, new RouteData());
var controller = new BaseController();
controller.ControllerContext = new ControllerContext(rc, controller);
var result = controller.UpdateSchoolComparisonListCookie(CompareActions.MAKE_DEFAULT_BENCHMARK, new BenchmarkSchoolViewModel()
{
Urn = "123"
});
Assert.AreEqual(1, controller.Response.Cookies.Count);
var cookie = JsonConvert.DeserializeObject <ComparisonListModel>(controller.Response.Cookies[CookieNames.COMPARISON_LIST].Value);
Assert.AreEqual(1, cookie.BenchmarkSchools.Count);
Assert.AreEqual("123", cookie.BenchmarkSchools[0].Urn);
}
protected virtual void Redirect301(HttpResponse response, string url)
{
HttpCookieCollection httpCookieCollection = new HttpCookieCollection();
for (int i = 0; i < response.Cookies.Count; i++)
{
HttpCookie item = response.Cookies[i];
if (item != null)
{
httpCookieCollection.Add(item);
}
}
response.Clear();
for (int j = 0; j < httpCookieCollection.Count; j++)
{
HttpCookie httpCookie = httpCookieCollection[j];
if (httpCookie != null)
{
response.Cookies.Add(httpCookie);
}
}
response.Status = "301 Moved Permanently";
response.StatusCode = (int)HttpStatusCode.MovedPermanently;
response.AppendHeader("Location", url);
response.Flush();
response.End();
}
public static void ClearAll()
{
if (HttpContext.Current == null)
{
return;
}
// просрачиваем куки
HttpCookieCollection cookies = HttpContext.Current.Request.Cookies;
List <HttpCookie> list = new List <HttpCookie>(cookies.Count);
foreach (string name in cookies)
{
cookies[name].Expires = DateTime.Now.AddDays(-1);
list.Add(cookies[name]);
}
cookies.Clear();
// отдаем клиенту просроченные куки
cookies = HttpContext.Current.Response.Cookies;
cookies.Clear();
foreach (HttpCookie cookie in list)
{
cookies.Add(cookie);
}
}
public void OnAuthorization_DeniedHookCustomActionResultIsContextsResult()
{
// Arrange
var tempUrl = "http://contoso.com";
var config = BuildConfiguration("~/home/permissions");
var deniedHookResult = new RedirectResult(tempUrl);
var authorizeFilter = new CustomReturningAuthorizeFilter(
config,
new RedirectResult(tempUrl),
new RedirectResult(tempUrl),
deniedHookResult
);
var persistedCookies = new HttpCookieCollection();
persistedCookies.Add(
new HttpCookie(PermissionHelper.RequestedPermissionCookieName, "email")
);
var context = BuildSignedAuthorizationContext(tempUrl, "email", persistedCookies);
// Act
authorizeFilter.OnAuthorization(context);
// Assert
Assert.Equal(deniedHookResult, context.Result);
}
public static void SignOut()
{
Initialize();
HttpContext context = HttpContext.Current;
if (context == null)
{
throw new HttpException("Context is null!");
}
HttpResponse response = context.Response;
if (response == null)
{
throw new HttpException("Response is null!");
}
HttpCookieCollection cc = response.Cookies;
cc.Remove(cookieName);
HttpCookie expiration_cookie = new HttpCookie(cookieName, String.Empty);
expiration_cookie.Expires = new DateTime(1999, 10, 12);
expiration_cookie.Path = cookiePath;
if (!String.IsNullOrEmpty(cookie_domain))
{
expiration_cookie.Domain = cookie_domain;
}
cc.Add(expiration_cookie);
Roles.DeleteCookie();
}
public void OnAuthorization_TriggersDeniedHook(
string requestUrl,
string permission,
bool expectedTrigger
)
{
// Arrange
var config = BuildConfiguration("~/home/permissions");
var authorizeFilter = new CustomDefaultAuthorizeFilter(config);
var persistedCookies = new HttpCookieCollection();
persistedCookies.Add(
new HttpCookie(
PermissionHelper.RequestedPermissionCookieName,
permission ?? string.Empty
)
);
var context = BuildSignedAuthorizationContext(requestUrl, permission, persistedCookies);
// Act
authorizeFilter.OnAuthorization(context);
// Assert
Assert.Equal(expectedTrigger, authorizeFilter.DeniedPermissionPromptHookTriggered);
}
/// <summary>
/// Mock cookies request and response
/// </summary>
/// <param name="useCookie"></param>
/// <returns></returns>
private static HttpContextBase GetControllerContext(bool useCookie)
{
HttpCookieCollection cookie = new HttpCookieCollection();
if (useCookie)
{
cookie.Add(new HttpCookie("CultureInfo", "en-GB"));
}
HttpRequestBase request = new System.Web.Fakes.ShimHttpRequestBase(new StubHttpRequestBase())
{
CookiesGet = () => { return(cookie); },
FormGet = () => { return(new NameValueCollection()); },
};
HttpResponseBase response = new System.Web.Fakes.ShimHttpResponseBase(new StubHttpResponseBase())
{
CookiesGet = () => { return(cookie); }
};
HttpContextBase context = new System.Web.Fakes.ShimHttpContextBase(new StubHttpContextBase())
{
RequestGet = () => { return(request); },
ResponseGet = () => { return(response); }
};
return(context);
}
private HttpCookie AddCookie(HttpCookieCollection cookies, string value)
{
var cookie = new HttpCookie(cookieName, value);
cookies.Add(cookie);
return(cookie);
}
public static void SetUnitsPreference(this HttpCookieCollection cookies, Units units)
{
HttpCookie cookie = new HttpCookie(Keys.UnitsPreference, units.ToString());
cookie.Expires = DateTime.Now.AddYears(10);
cookies.Add(cookie);
}
public void Init()
{
request = new Mock <HttpRequestBase>(MockBehavior.Strict);
var cookies = new HttpCookieCollection();
request.SetupGet(req => req.Cookies).Returns(cookies);
var uri = new Uri("https://www.example.com/pixel?dr=https%3A%2F%2Fwww.example.com");
request.SetupGet(req => req.Url).Returns(uri);
var referrer = new Uri("https://www.example.com/referrer");
request.SetupGet(req => req.UrlReferrer).Returns(referrer);
request.SetupGet(req => req.UserAgent).Returns("my browser");
response = new Mock <HttpResponseBase>(MockBehavior.Strict);
response.SetupGet(resp => resp.Cookies).Returns(cookies);
response.Setup(resp =>
resp.SetCookie(It.IsAny <HttpCookie>()))
.Callback <HttpCookie>((cookie) => cookies.Add(cookie));
context = new Mock <HttpContextBase>(MockBehavior.Strict);
context.SetupGet(ctx => ctx.Request).Returns(request.Object);
context.SetupGet(ctx => ctx.Response).Returns(response.Object);
rc = new RequestContext(context.Object, new RouteData());
}
public async System.Threading.Tasks.Task UpdateActionCallsCookieManagerWhenComparisonListClearedAsync()
{
var request = new Mock <HttpRequestBase>(MockBehavior.Strict);
var response = new Mock <HttpResponseBase>(MockBehavior.Strict);
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
context.SetupGet(x => x.Request).Returns(request.Object);
context.SetupGet(x => x.Response).Returns(response.Object);
var requestCookies = new HttpCookieCollection();
var listCookie = new SchoolComparisonListModel();
listCookie.BenchmarkSchools = new List <BenchmarkSchoolModel>()
{
new BenchmarkSchoolModel()
{
Urn = "123", Name = "test"
}
};
requestCookies.Add(new HttpCookie(CookieNames.COMPARISON_LIST, JsonConvert.SerializeObject(listCookie)));
context.SetupGet(x => x.Request.Cookies).Returns(requestCookies);
var responseCookies = new HttpCookieCollection();
context.SetupGet(x => x.Response.Cookies).Returns(responseCookies);
var rc = new RequestContext(context.Object, new RouteData());
dynamic apiResponse = new System.Dynamic.ExpandoObject();
apiResponse.Results = new object[0];
apiResponse.NumberOfResults = 0;
apiResponse.Facets = string.Empty;
var mockEdubaseDataService = new Mock <IContextDataService>();
dynamic serviceResponse = new System.Dynamic.ExpandoObject();
serviceResponse.Results = new object[0];
serviceResponse.NumberOfResults = 0;
serviceResponse.Facets = string.Empty;
var mockFinancialDataService = new Mock <IFinancialDataService>();
var mockCookieManager = new Mock <ISchoolBenchmarkListService>();
var fakeSchoolComparisonList = new SchoolComparisonListModel();
fakeSchoolComparisonList.HomeSchoolUrn = "123";
fakeSchoolComparisonList.HomeSchoolName = "test";
fakeSchoolComparisonList.HomeSchoolType = "test";
fakeSchoolComparisonList.HomeSchoolFinancialType = "Academies";
fakeSchoolComparisonList.BenchmarkSchools.Add(new BenchmarkSchoolModel {
Urn = "123", EstabType = "Academies"
});
mockCookieManager.Setup(m => m.GetSchoolBenchmarkList()).Returns(fakeSchoolComparisonList);
var controller = new BenchmarkListController(mockEdubaseDataService.Object, mockCookieManager.Object, mockFinancialDataService.Object);
controller.ControllerContext = new ControllerContext(rc, controller);
var result = await controller.UpdateBenchmarkBasket(null, CookieActions.RemoveAll);
mockCookieManager.Verify(m => m.ClearSchoolBenchmarkList(), Times.Once);
}
public static UmbracoContext GetMockUmbracoContext(Uri requestUri, HttpCookie mockCookie = null)
{
//var mockHttpContext = MockRepository.GenerateStub<HttpContextBase>();
//var mockHttpRequest = MockRepository.GenerateStub<HttpRequestBase>();
//var mockHttpResponse = MockRepository.GenerateStub<HttpResponseBase>();
//SetupResult.For(mockHttpContext.Request).Return(mockHttpRequest);
//SetupResult.For(mockHttpRequest.Url).Return(requestUri);
//SetupResult.For(mockHttpRequest.Cookies).Return(cookieCollection);
//SetupResult.For(mockHttpContext.Response).Return(mockHttpResponse);
//SetupResult.For(mockHttpResponse.Cookies).ReturncookieCollection);
var umbracoContext = MockRepository.GenerateStrictMock <UmbracoContext>();
var cookieCollection = new HttpCookieCollection();
SetupResult.For(umbracoContext.HttpContext.Request.Cookies).Return(cookieCollection);
if (mockCookie != null)
{
cookieCollection.Add(mockCookie);
umbracoContext.Expect(c => c.HttpContext.Response.Cookies.Add(mockCookie));
}
SetupResult.For(umbracoContext.HttpContext.Request.Url).Return(requestUri);
return(umbracoContext);
}
public static void ClearAnonymousUser(this HttpCookieCollection cookies)
{
cookies.Add(new HttpCookie(anonymousUserCookieName)
{
Expires = DateTime.Now.AddDays(-1)
});
}
public void CanLoadTempDataFromCookie()
{
var tempData = new Dictionary <string, object>();
tempData.Add("abc", "easy as 123");
tempData.Add("price", 1.234);
string serializedTempData = CookieTempDataProvider.DictionaryToBase64String(tempData);
var cookies = new HttpCookieCollection();
var httpCookie = new HttpCookie("__ControllerTempData");
httpCookie.Value = serializedTempData;
cookies.Add(httpCookie);
var requestMock = new Mock <HttpRequestBase>();
requestMock.Setup(r => r.Cookies).Returns(cookies);
var responseMock = new Mock <HttpResponseBase>();
responseMock.Setup(r => r.Cookies).Returns(cookies);
var httpContextMock = new Mock <HttpContextBase>();
httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
httpContextMock.Setup(c => c.Response).Returns(responseMock.Object);
ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
IDictionary <string, object> loadedTempData = provider.LoadTempData(null /* controllerContext */);
Assert.AreEqual(2, loadedTempData.Count);
Assert.AreEqual("easy as 123", loadedTempData["abc"]);
Assert.AreEqual(1.234, loadedTempData["price"]);
}
public void SetupContext()
{
var request = new Mock <HttpRequestBase>(MockBehavior.Strict);
var response = new Mock <HttpResponseBase>(MockBehavior.Strict);
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
context.SetupGet(x => x.Request).Returns(request.Object);
context.SetupGet(x => x.Response).Returns(response.Object);
var requestCookies = new HttpCookieCollection();
var listCookie = new SchoolComparisonListModel();
listCookie.HomeSchoolUrn = "123";
listCookie.HomeSchoolName = "test";
listCookie.HomeSchoolType = "test";
listCookie.HomeSchoolFinancialType = "Academies";
listCookie.BenchmarkSchools = new List <BenchmarkSchoolModel>()
{
new BenchmarkSchoolModel()
{
Urn = "123", Name = "test", EstabType = "Academies"
}
};
requestCookies.Add(new HttpCookie(CookieNames.COMPARISON_LIST, JsonConvert.SerializeObject(listCookie)));
context.SetupGet(x => x.Request.Cookies).Returns(requestCookies);
var responseCookies = new HttpCookieCollection();
context.SetupGet(x => x.Response.Cookies).Returns(responseCookies);
_rc = new RequestContext(context.Object, new RouteData());
}
private void ReadCookies(IRequestValues values)
{
var cookies = new HttpCookieCollection();
foreach (var cookievalues in Request.Headers.GetCookies())
{
foreach (var cookie in cookievalues.Cookies)
{
var c = new HttpCookie(cookie.Name, cookie.Value)
{
Domain = cookievalues.Domain,
HttpOnly = cookievalues.HttpOnly,
Path = cookievalues.Path,
Secure = cookievalues.Secure,
};
if (cookievalues.Expires.HasValue)
{
c.Expires = cookievalues.Expires.Value.DateTime;
}
cookies.Add(c);
}
}
values.Cookies = 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, ITextParser reader)
{
//key: "value"; key: "value"
var cookies = new HttpCookieCollection();
while (!reader.EndOfFile)
{
// 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 HttpCookie(cookieName, value));
}
//else
// cookies.Add(new RequestCookie(cookieName, string.Empty));
// consume whitespaces and cookie separator
reader.ConsumeWhiteSpaces(';');
}
return new CookieHeader(cookies);
}
public void WhenLoadingTempDatFromValidCookie_ThenReturnsDictionaryWithEntries()
{
var cookie = new HttpCookie("__ControllerTempData");
var initialTempData = new Dictionary <string, object>();
initialTempData.Add("WhatIsInHere?", "Stuff");
cookie.Value = CookieTempDataProvider.SerializeToBase64EncodedString(initialTempData);
var cookies = new HttpCookieCollection();
cookies.Add(cookie);
var requestMock = new Mock <HttpRequestBase>();
requestMock.Setup(r => r.Cookies).Returns(cookies);
var httpContextMock = new Mock <HttpContextBase>();
httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
httpContextMock.Setup(c => c.Response).Returns((HttpResponseBase)null);
var provider = new CookieTempDataProvider(httpContextMock.Object);
var tempData = provider.LoadTempData(null);
Assert.Equal("Stuff", tempData["WhatIsInHere?"]);
}
public void LoadTempDataIgnoresNullResponseCookieDoesNotThrowException()
{
HttpCookie cookie = new HttpCookie("__ControllerTempData");
var initialTempData = new Dictionary <string, object>();
initialTempData.Add("WhatIsInHere?", "Stuff");
cookie.Value = CookieTempDataProvider.DictionaryToBase64String(initialTempData);
var cookies = new HttpCookieCollection();
cookies.Add(cookie);
var requestMock = new Mock <HttpRequestBase>();
requestMock.Setup(r => r.Cookies).Returns(cookies);
var responseMock = new Mock <HttpResponseBase>();
responseMock.Setup(r => r.Cookies).Returns((HttpCookieCollection)null);
var httpContextMock = new Mock <HttpContextBase>();
httpContextMock.Setup(c => c.Request).Returns(requestMock.Object);
httpContextMock.Setup(c => c.Response).Returns(responseMock.Object);
ITempDataProvider provider = new CookieTempDataProvider(httpContextMock.Object);
IDictionary <string, object> tempData = provider.LoadTempData(null /* controllerContext */);
Assert.AreEqual("Stuff", tempData["WhatIsInHere?"]);
}
public ActionResult LogOff()
{
if (Properties.Settings.Default.UseDevAuthentication)
{
Log.Information("Dev LogOff");
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
}
else
{
Log.Information("GSA LogOff");
}
Session.Abandon();
Response.Cookies.Clear();
var requestCookies = new HttpCookieCollection();
for (int z = 0; z < Request.Cookies.Count; ++z)
{
requestCookies.Add(Request.Cookies[z]);
}
for (int z = 0; z < requestCookies.Count; ++z)
{
var c = requestCookies[z];
Response.Cookies.Add(new HttpCookie(c.Name)
{
Domain = c.Domain,
Expires = DateTime.Now.AddYears(-1),
HttpOnly = c.HttpOnly,
Path = c.Path,
Secure = c.Secure,
Shareable = c.Shareable,
});
}
return(RedirectToAction(ActionNames.Login));
}
private static void SetCookie(HttpCookie cookie)
{
HttpCookieCollection cookies = HttpContext.Current.Response.Cookies;
cookies.Remove(cookie.Name); // Doesn't delete from the client, but replacing it so it is unimportant.
cookies.Add(cookie);
}
public void WithInitialStateAndNoValuesClearsCookie()
{
// Arrange and Setup
var cookies = new HttpCookieCollection();
var cookie = new HttpCookie("__Controller::TempData");
cookie.HttpOnly = true;
cookie.Secure = true;
cookies.Add(cookie);
cookie["message"] = "clear";
var httpContext = new Mock <HttpContextBase>();
httpContext.Setup(c => c.Request.Cookies).Returns(cookies);
ITempDataProvider provider = new CookieTempDataProvider(httpContext.Object);
var controllerContext = new ControllerContext();
var tempData = provider.LoadTempData(controllerContext);
// Validate
provider.SaveTempData(controllerContext, new Dictionary <string, object>());
Assert.Equal(1, cookies.Count);
Assert.True(cookies[0].HttpOnly);
Assert.True(cookies[0].Secure);
Assert.Equal("", cookies[0].Value);
}
private static HttpContextBase GetHttpContext(IDictionary <string, string> cookies)
{
var httpRequest = new Mock <HttpRequestBase>();
var requestCookies = new HttpCookieCollection();
var httpResponse = new Mock <HttpResponseBase>();
var responseCookies = new HttpCookieCollection();
foreach (var key in cookies.Keys)
{
var requestCookie = new HttpCookie(key, cookies[key]);
requestCookies.Add(requestCookie);
var responseCookie = new HttpCookie(key, cookies[key]);
responseCookies.Add(responseCookie);
}
httpRequest.Setup(r => r.Cookies).Returns(requestCookies);
httpResponse.Setup(r => r.Cookies).Returns(responseCookies);
var httpContext = new Mock <HttpContextBase>();
httpContext.Setup(c => c.Request).Returns(httpRequest.Object);
httpContext.Setup(c => c.Response).Returns(httpResponse.Object);
return(httpContext.Object);
}
public void TestInitialize()
{
_context = new Mock <HttpContextBase>();
_request = new Mock <HttpRequestBase>();
_response = new Mock <HttpResponseBase>();
var servervVariables = new NameValueCollection();
servervVariables.Add("AUTH_USER", "ali");
servervVariables.Add("AUTH_TYPE", "Forms");
servervVariables.Add("AUTH_PASSWORD", "123");
var cookies = new HttpCookieCollection();
cookies.Add(new HttpCookie("COOKIE_10", "ck1"));
cookies.Add(new HttpCookie("COOKIE_11", "ck2"));
cookies.Add(new HttpCookie("COOKIE_2", "ck3"));
cookies.Add(new HttpCookie("COOKIE_3", "ck4"));
cookies.Add(new HttpCookie("COOKIE_4", "ck5"));
var form = new NameValueCollection();
form.Add("FORM_B_XXX_B", "F1");
form.Add("FORM_B_YYY_B", "F2");
form.Add("FORM_C", "F3");
form.Add("FORM_D", "F4");
form.Add("FORM_E", "F5");
var headers = new NameValueCollection();
headers.Add("HEADER_B_XXX_B", "H1");
headers.Add("HEADER_B_YYY_B", "H2");
headers.Add("HEADER_C", "H3");
headers.Add("HEADER_D", "H4");
headers.Add("HEADER_E", "H5");
_request.SetupGet(x => x.ServerVariables).Returns(servervVariables);
_request.SetupGet(x => x.Cookies).Returns(cookies);
_request.SetupGet(x => x.Form).Returns(form);
_request.SetupGet(x => x.QueryString).Returns(new NameValueCollection());
_request.SetupGet(x => x.Headers).Returns(headers);
_context.SetupGet(x => x.Request).Returns(_request.Object);
_context.SetupGet(x => x.Response).Returns(_response.Object);
}
/// <summary>
/// The get shim http context base, used for tests. Must be encapsulated in
/// using (ShimsContext.Create())
/// {}
/// statement.
/// </summary>
/// <param name="useCookie">
/// Set to true if cookies are used.
/// </param>
/// <returns>
/// Shimmed httpContextBase. <see cref="HttpContextBase"/>.
/// </returns>
private static HttpContextBase GetStubHttpContextBase(bool useCookie = true)
{
var cookie = new HttpCookieCollection();
cookie.Add(new HttpCookie("CultureInfo", "en-GB"));
var queryString = new NameValueCollection();
queryString.Add("error", "false");
queryString.Add("handler", "true");
var cultureInfo = new HttpCookie("CultureInfo", "en-GB");
if (useCookie)
{
cookie.Add(cultureInfo);
}
HttpRequestBase stubHttpRequestBase = new System.Web.Fakes.StubHttpRequestBase()
{
CookiesGet = () => { return(cookie); },
FormGet = () => { return(new NameValueCollection()); },
QueryStringGet = () => { return(queryString); }
};
// Might be needed? instead of stubHttpRequestBase: HttpRequestWrapper httpRequestWrapper = new System.Web.Fakes.ShimHttpRequestWrapper()
// {
// CookiesGet = () => { return cookie; },
// FormGet = () => { return new NameValueCollection(); },
// QueryStringGet = () => { return queryString; }
// };
HttpResponseBase response = new System.Web.Fakes.StubHttpResponseBase()
{
CookiesGet = () => { return(cookie); }
};
HttpServerUtilityBase untilityBase = new System.Web.Fakes.StubHttpServerUtilityBase()
{
UrlEncodeString = (info) => { return(cultureInfo.ToString()); }
};
HttpContextBase stubHttpContext = new System.Web.Fakes.StubHttpContextBase()
{
RequestGet = () => { return(stubHttpRequestBase); },
ResponseGet = () => { return(response); },
ServerGet = () => { return(untilityBase); }
};
return(stubHttpContext);
}
public void Can_Show_Sorted_YearAsc_List()
{
//Arrange
//создаем cookie и присваиваем параметру pageSize значение 2
var cookies = new HttpCookieCollection();
cookies.Add(new HttpCookie("pageSize", "3"));
//Создаем HttpContext и присваиваем cookies для Request и Response
var mockHttpContext = Substitute.For <HttpContextBase>();
mockHttpContext.Request.Cookies.Returns(cookies);
mockHttpContext.Response.Cookies.Returns(cookies);
// создаем Mock-контейнер и добавляем книги
Mock <IBookContainer> mock = new Mock <IBookContainer>();
mock.Setup(m => m.Books).Returns(new List <Book>
{
new Book {
Title = "T1", PublishYear = 1959
},
new Book {
Title = "T2", PublishYear = 1971
},
new Book {
Title = "T3", PublishYear = 1985
},
new Book {
Title = "T4", PublishYear = 1976
},
new Book {
Title = "T5", PublishYear = 1951
}
}.AsQueryable());
//Создаем экземпляр контроллера
BookController controller = new BookController(mock.Object);
//Эмулируем httpContext для контроллера
controller.ControllerContext = new ControllerContext
{
Controller = controller,
HttpContext = mockHttpContext
};
int pageNum = 2;
//Act - вызываем сортировк
//в качестве количества книг на странице передаем null - значение будет браться из cookie (по умолчанию равно 12, если не найдено в cookie)
BookViewModel bookViewModel = (BookViewModel)controller.BooksList(pageNum, null, "Year", "Asc").Model;
bookViewModel.SortBooks();
Book[] books = bookViewModel.Books.ToArray();
//Assert
Assert.AreEqual(books.Count(), 2);
Assert.AreEqual(books[0].Title, "T4");
Assert.AreEqual(books[1].Title, "T3");
}
/// <summary>
/// Mocks the http context to test against
/// </summary>
/// <param name="fullUrl"></param>
/// <param name="routeData"></param>
/// <returns></returns>
private void CreateContext(Uri fullUrl, RouteData routeData = null)
{
//Request context
RequestContext = MockRepository.GenerateMock <RequestContext>();
//Cookie collection
var cookieCollection = new HttpCookieCollection();
cookieCollection.Add(new HttpCookie("UMB_UCONTEXT", "FBA996E7-D6BE-489B-B199-2B0F3D2DD826"));
//Request
var request = MockRepository.GenerateMock <HttpRequestBase>();
request.Stub(x => x.AppRelativeCurrentExecutionFilePath).Return("~" + fullUrl.AbsolutePath);
request.Stub(x => x.PathInfo).Return(string.Empty);
request.Stub(x => x.RawUrl).Return(VirtualPathUtility.ToAbsolute("~" + fullUrl.AbsolutePath, "/"));
request.Stub(x => x.RequestContext).Return(RequestContext);
request.Stub(x => x.Url).Return(fullUrl);
request.Stub(x => x.ApplicationPath).Return("/");
request.Stub(x => x.Cookies).Return(cookieCollection);
request.Stub(x => x.ServerVariables).Return(new NameValueCollection());
var queryStrings = HttpUtility.ParseQueryString(fullUrl.Query);
request.Stub(x => x.QueryString).Return(queryStrings);
request.Stub(x => x.Form).Return(new NameValueCollection());
//Cache
var cache = MockRepository.GenerateMock <HttpCachePolicyBase>();
//Response
//var response = new FakeHttpResponse();
var response = MockRepository.GenerateMock <HttpResponseBase>();
response.Stub(x => x.ApplyAppPathModifier(null)).IgnoreArguments().Do(new Func <string, string>(appPath => appPath));
response.Stub(x => x.Cache).Return(cache);
//Server
var server = MockRepository.GenerateStub <HttpServerUtilityBase>();
server.Stub(x => x.MapPath(Arg <string> .Is.Anything)).Return(Environment.CurrentDirectory);
//HTTP Context
HttpContext = MockRepository.GenerateMock <HttpContextBase>();
HttpContext.Stub(x => x.Cache).Return(HttpRuntime.Cache);
HttpContext.Stub(x => x.Items).Return(new Dictionary <object, object>());
HttpContext.Stub(x => x.Request).Return(request);
HttpContext.Stub(x => x.Server).Return(server);
HttpContext.Stub(x => x.Response).Return(response);
RequestContext.Stub(x => x.HttpContext).Return(HttpContext);
if (routeData != null)
{
RequestContext.Stub(x => x.RouteData).Return(routeData);
}
}
private static void setCookie(string name, string value, HttpCookieCollection cookies)
{
HttpCookie myCookie = new HttpCookie(name);
myCookie["token"] = value;
myCookie.Expires = DateTime.Now.AddDays(5d);
cookies.Add(myCookie);
}
public void ShouldNotDisplayBannerIfCookieIsPresent()
{
_cookieCollection.Add(new HttpCookie(_testCookieName));
var response = _cookieService.ShowCookieForBanner(_httpContext.Object);
response.Should().BeFalse();
_cookieCollection.AllKeys.Length.Should().Be(1);
}
public void GetIrcdaCookieValueTest()
{
string otherCookieVal = "Bobs Cookie";
string testKey = "testkey";
HttpCookie testCookie = CookieTools.MakeCookie(CookieTools.HobbesCookieName, null);
testCookie = CookieTools.AddTo(testCookie, testKey, "Bobs Cookie");
HttpCookie testCookie2 = CookieTools.MakeCookie("Bobs Cookie", otherCookieVal);
HttpCookieCollection cookies = new HttpCookieCollection();
cookies.Add(testCookie);
cookies.Add(testCookie2);
string result = CookieTools.GetHobbesCookieValue(cookies, testKey);
Assert.AreEqual("Bobs Cookie", result, "Problem: Didn't get value");
}
static void ReplaceVisitorIdCookie(HttpCookieCollection responseCookies, string visitorId)
{
responseCookies.Remove(NcbtVisitorIdCookieName);
responseCookies.Add(new HttpCookie(NcbtVisitorIdCookieName, visitorId)
{
Expires = DateTime.UtcNow.AddYears(10)
});
}
public void GetFilterValueReturnsValueFromCookieIfQueryStringDoesNotContainKey()
{
// Arrange
const string key = "my-key";
const string value = "my-cookie-value";
var request = new Mock<HttpRequestBase>();
request.Setup(c => c.QueryString).Returns(new NameValueCollection());
var cookies = new HttpCookieCollection();
var cookie = new HttpCookie("foo");
cookie[key] = value;
cookies.Add(cookie);
request.Setup(c => c.Cookies).Returns(cookies);
// Act
var returnedValue = PageUtils.GetFilterValue(request.Object, "foo", key);
// Assert
Assert.Equal(value, returnedValue);
}
public void IsAuthenticatedReturnsFalseIfAuthCookieInCollectionAndIsNotAValidAdminAuthCookie()
{
// Arrange
var mockRequest = new Mock<HttpRequestBase>();
var cookies = new HttpCookieCollection();
mockRequest.Setup(m => m.Cookies).Returns(cookies);
cookies.Add(new HttpCookie(".ASPXADMINAUTH", "test"));
// Act
bool authorized = AdminSecurity.IsAuthenticated(mockRequest.Object);
// Assert
Assert.False(authorized);
}
public void IsAuthenticatedReturnsTrueIfAuthCookieIsValid()
{
// Arrange
var mockRequest = new Mock<HttpRequestBase>();
var cookies = new HttpCookieCollection();
mockRequest.Setup(m => m.Cookies).Returns(cookies);
cookies.Add(AdminSecurity.GetAuthCookie());
// Act
bool authorized = AdminSecurity.IsAuthenticated(mockRequest.Object);
// Assert
Assert.True(authorized);
}
internal static Mock<HttpContextBase> CreateCookieContext(HttpCookie requestCookie = null, HttpCookie responseCookie = null)
{
Mock<HttpContextBase> context = new Mock<HttpContextBase>();
HttpCookieCollection requestCookies = new HttpCookieCollection();
if (requestCookie != null)
{
requestCookies.Add(requestCookie);
}
HttpCookieCollection responseCookies = new HttpCookieCollection();
if (responseCookie != null)
{
responseCookies.Add(responseCookie);
}
context.Setup(c => c.Request.Cookies).Returns(requestCookies);
context.Setup(c => c.Response.Cookies).Returns(responseCookies);
context.Setup(c => c.Items).Returns(new Hashtable());
return context;
}
public void PersistFilterUsesExistingCookie()
{
// Arrange
var cookieName = "my-cookie";
var cookies = new HttpCookieCollection();
cookies.Add(new HttpCookie(cookieName));
var response = new Mock<HttpResponseBase>();
response.Setup(c => c.Cookies).Returns(cookies);
// Act
PageUtils.PersistFilter(response.Object, "my-cookie", new Dictionary<string, string>());
// Assert
Assert.Equal(1, cookies.Count);
}
