public void SetUp()
{
this.actionExecutingContext = new ActionExecutingContext
{
ActionParameters = new Dictionary <string, object>()
};
this.userStoreMock = MockRepository.GenerateMock <IUserStore <ApplicationUser> >();
this.dataProtectionProviderMock = MockRepository.GenerateMock <IDataProtectionProvider>();
var dataProtector = MockRepository.GenerateMock <IDataProtector>();
this.dataProtectionProviderMock.Expect(mock => mock.Create(Arg <string> .Is.Anything)).Return(dataProtector);
this.userManager = new ApplicationUserManager(this.userStoreMock, this.dataProtectionProviderMock);
clientIdCalculatorMock = MockRepository.GenerateMock <ClientIdCalculator>();
//need to simulate like the parameter exists on the method
this.actionExecutingContext.ActionParameters[UserContextAttribute.USER_CONTEXT_KEY] = null;
HttpContextBase httpContextBase = MockRepository.GenerateMock <HttpContextBase>();
this.actionExecutingContext.HttpContext = httpContextBase;
IPrincipal principal = MockRepository.GenerateMock <IPrincipal>();
httpContextBase.Expect(contextBase => contextBase.User)
.Repeat.Any()
.Return(principal);
this.identity = MockRepository.GenerateMock <IIdentity>();
principal.Expect(mock => mock.Identity)
.Repeat.Any()
.Return(this.identity);
this.identity.Expect(mock => mock.IsAuthenticated)
.Repeat.Once()
.Return(true);
HttpRequestBase requestBaseMock = MockRepository.GenerateMock <HttpRequestBase>();
httpContextBase.Expect(mock => mock.Request)
.Return(requestBaseMock);
this.requestParameters = new NameValueCollection();
requestBaseMock.Expect(mock => mock.Params)
.Return(this.requestParameters);
this.userContextActionFilter = new UserContextAttribute();
this.applicationUser = new ApplicationUser()
{
Id = "user id",
CurrentGamingGroupId = 315
};
Task <ApplicationUser> task = Task.FromResult(this.applicationUser);
//TODO can't figure out how to mock the GetUserId() extension method, so have to be less strict here
this.userStoreMock.Expect(mock => mock.FindByIdAsync(Arg <string> .Is.Anything))
.Repeat.Once()
.Return(task);
}
public void WhenCombinationContainsNoContent_ShouldNotThrow()
{
_stubHttpContext.Expect(hc => hc.Response).Return(_stubResponse);
_stubHttpContext.Expect(hc => hc.Request).Return(_stubRequest);
_stubRequest.Expect(r => r.Headers).Return(new NameValueCollection {
{ HttpHeaders.AcceptEncoding, "" }
});
_stubResponse.ContentEncoding = Encoding.UTF8;
_stubResponse.ContentType = MimeTypes.TextCss;
_stubResponse.AddHeader(HttpHeaders.ContentLength, "15");
_stubResponse.Expect(r => r.OutputStream).Return(new MemoryStream(8092)).Repeat.Twice();
_stubResponse.Expect(r => r.Cache).Return(_stubCache);
var emptyCombination = new IncludeCombination(IncludeType.Css, new[] { "foo.css" }, "", DateTime.UtcNow, new CssTypeElement());
_stubCombiner.Expect(c => c.GetCombination("foo")).Return(emptyCombination);
var result = new IncludeCombinationResult(_stubCombiner, "foo", DateTime.UtcNow);
result.ExecuteResult(_controllerContext);
}
public void TestSetup()
{
_mocks = new MockRepository();
_mockHttpContext = _mocks.StrictMock <HttpContextBase>();
_mockRequest = _mocks.StrictMock <HttpRequestBase>();
_mockResponse = _mocks.StrictMock <HttpResponseBase>();
_mockFilterContext = _mocks.StrictMock <ActionExecutedContext>();
_filter = new DebugAttribute();
_mocks.ReplayAll();
_mockFilterContext.Expect(fc => fc.HttpContext).Return(_mockHttpContext);
_mockHttpContext.Expect(hc => hc.Request).Return(_mockRequest);
}
public void WhenNoCombinationExists_ResponseCodeShouldBe404()
{
_mockHttpContext.Expect(hc => hc.Response).Return(_mockResponse);
_mockResponse.Expect(r => r.ContentEncoding = Encoding.UTF8);
_mockResponse.Expect(r => r.StatusCode = (int)HttpStatusCode.NotFound);
_stubCombiner.Expect(c => c.GetCombination("foo")).Return(null);
var result = new IncludeCombinationResult(_stubCombiner, "foo", DateTime.UtcNow);
result.ExecuteResult(_controllerContext);
_mocks.VerifyAll();
}
public void InitializeTest()
{
EducationContext = new EducationDataContext();
Container = AssemblySetup.CreateWindsorContainer(EducationContext);
RepositoryContainer repositoryContainer = new RepositoryContainer(Container, EducationContext);
SchoolDistrictManager logicManager = new SchoolDistrictManager(repositoryContainer, new DataTableBinder(), new UserAuditor());
Target = new StudentController(logicManager);
User userEntity = EducationContext.Users.Include("UserRoles.Role").Include("UserRoles.Schools").Include("UserRoles.Providers").Single(s => s.UserKey == "Bob");
User = new EducationSecurityPrincipal(userEntity);
MockHttpContext = MockHttpContextFactory.Create();
MockHttpContext.Expect(m => m.User).Return(User);
ControllerContext context = new ControllerContext(MockHttpContext, new RouteData(), Target);
Target.ControllerContext = context;
}
private static HttpContextBase CreateHttpContextBase(bool mockableContext, string userKey)
{
if (mockableContext)
{
HttpContextBase httpContext = MockHttpContextFactory.Create();
httpContext.Expect(m => m.User).Return(MockRepository.GenerateMock <IPrincipal>());
httpContext.User.Expect(m => m.Identity).Return(MockRepository.GenerateMock <IIdentity>());
httpContext.User.Identity.Expect(m => m.IsAuthenticated).Return(false);
httpContext.Request.Expect(m => m.Url).Return(new Uri("http://site.com/Bob/123"));
httpContext.Request.Expect(m => m.RawUrl).Return("Bob/123");
httpContext.Request.Headers.Add("Host", "site.com");
return(httpContext);
}
else
{
return(new UserHttpContext(userKey));
}
}
public void WhenDebugIs1InQueryString_CookieShouldBeCreatedAndAddedToResponse_WithDebugCookie()
{
var data = new CookiesData {
Cookies = new HttpCookieCollection {
new HttpCookie("debug", "1")
}, DebugCookieWasPresent = true
};
_mockFilterContext.Expect(fc => fc.HttpContext).Return(_mockHttpContext);
_mockRequest.Expect(r => r.QueryString).Return(new NameValueCollection {
{ "debug", "1" }
});
_mockHttpContext.Expect(hc => hc.Response).Return(_mockResponse);
_mockResponse.Expect(r => r.Cookies).Return(data.Cookies);
_filter.OnActionExecuted(_mockFilterContext);
var result = data.Cookies["debug"];
Assert.IsNotNull(result);
Assert.AreEqual("1", result.Value);
_mocks.VerifyAll();
}
