public void IsInDebugMode_ShouldBeCorrect(DebugMode data)
{
_mockRequest.Expect(r => r.QueryString).Return(data.QueryString);
_mockRequest.Expect(r => r.Cookies).Return(data.Cookies);
Assert.AreEqual(data.Expected, _html.IsInDebugMode());
}
private TestClientDataTable CreateTarget(int?sortColumnIndex, string sortDirection)
{
HttpRequestBase request = MockHttpContextFactory.CreateRequest();
request.Expect(m => m["iSortCol_0"]).Return(sortColumnIndex.HasValue ? sortColumnIndex.Value.ToString() : null);
request.Expect(m => m["sSortDir_0"]).Return(sortDirection);
return(new TestClientDataTable(request));
}
public void GivenHttpRequest_AndApplicationPathDoesNotTerminateWithSlash_WhenIGetApplicationUri_ThenApplicationUriIsExtractedFromRequest_AndApplicationUriIsterminatedWithSlash()
{
HttpRequestBase request = MockRepository.GenerateMock <HttpRequestBase>();
request.Expect(m => m.Url).Return(new Uri("http://bob.com/management/address"));
request.Expect(m => m.ApplicationPath).Return("/management");
request.Expect(m => m.Headers).Return(new NameValueCollection());
string actual = AuthenticationUtility.GetApplicationUri(request);
Assert.AreEqual("http://bob.com/management/", actual);
}
public void GivenSortOnFirstColumn_WhenGenerateDataTableResultViewModel_ThenSucceed()
{
DataTableRequestModel model = new DataTableRequestModel {
iDisplayLength = 10
};
User userEntity = EducationContext.Users.First(u => u.UserRoles.Select(ur => ur.Role).Any(r => r.Name == SecurityRoles.DataAdmin));
EducationSecurityPrincipal user = new EducationSecurityPrincipal(userEntity);
HttpRequestBase mockRequest = MockHttpContextFactory.CreateRequest();
mockRequest.Expect(m => m["iSortCol_0"]).Return("0");
mockRequest.Expect(m => m["sSortDir_0"]).Return("asc");
ServiceTypeClientDataTable dataTable = new ServiceTypeClientDataTable(mockRequest, user);
Target.GenerateDataTableResultViewModel(model, dataTable);
}
public virtual void SetUp()
{
autoMocker = new RhinoAutoMocker <GameDefinitionController>();
autoMocker.Get <IGameDefinitionRetriever>()
.Expect(mock => mock.GetTrendingGames(GameDefinitionController.NUMBER_OF_TRENDING_GAMES_TO_SHOW,
GameDefinitionController.NUMBER_OF_DAYS_OF_TRENDING_GAMES))
.Return(trendingGames);
AutomapperConfiguration.Configure();
urlHelperMock = MockRepository.GenerateMock <UrlHelper>();
autoMocker.ClassUnderTest.Url = urlHelperMock;
asyncRequestMock = MockRepository.GenerateMock <HttpRequestBase>();
asyncRequestMock.Expect(x => x.Headers)
.Repeat.Any()
.Return(new System.Net.WebHeaderCollection
{
{ "X-Requested-With", "XMLHttpRequest" }
});
var context = MockRepository.GenerateMock <HttpContextBase>();
context.Expect(x => x.Request)
.Repeat.Any()
.Return(asyncRequestMock);
autoMocker.ClassUnderTest.ControllerContext = new ControllerContext(context, new RouteData(), autoMocker.ClassUnderTest);
currentUser = new ApplicationUser()
{
Id = "user id",
CurrentGamingGroupId = 15151
};
}
protected void StubReceivedAjaxRequest(bool isAjaxRequest)
{
var headers = new WebHeaderCollection();
if (isAjaxRequest)
{
headers.Add("X-Requested-With", "XMLHttpRequest");
}
HttpRequest.Expect(a => a.Headers).Return(headers);
}
public void WhenCombinationExists_ShouldCorrectlySetUpResponse()
{
_mockHttpContext.Expect(hc => hc.Response).Return(_mockResponse);
_mockHttpContext.Expect(hc => hc.Request).Return(_mockRequest);
_mockRequest.Expect(r => r.Headers[HttpHeaders.AcceptEncoding]).Return("");
_mockResponse.Expect(r => r.ContentEncoding = Encoding.UTF8);
_mockResponse.Expect(r => r.ContentType = MimeTypes.TextCss);
_mockResponse.Expect(r => r.AddHeader(HttpHeaders.ContentLength, "16"));
_mockResponse.Expect(r => r.OutputStream).Return(new MemoryStream(8092)).Repeat.Twice();
_mockResponse.Expect(r => r.Cache).Return(_mockCachePolicy);
_mockCachePolicy.Expect(cp => cp.SetETag(Arg <string> .Matches(etag => etag.StartsWith("foo") && etag.EndsWith(_cssCombination.LastModifiedAt.Ticks.ToString()))));
_stubCombiner.Expect(c => c.GetCombination("foo")).Return(_cssCombination);
var result = new IncludeCombinationResult(_stubCombiner, "foo", DateTime.UtcNow);
result.ExecuteResult(_controllerContext);
_mocks.VerifyAll();
}
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 GivenValidModelWithId_WhenLoginAuditDataTableAjaxHandler_TheJSonResultReturned()
{
HttpRequestBase MockRequest = MockRepository.GenerateMock <HttpRequestBase>();
MockRequest.Expect(m => m["id"]).Return("1");
DataTableRequestModel model = new DataTableRequestModel();
MockHttpContext.Expect(c => c.Request).Return(MockRequest).Repeat.Any();
var result = Target.LoginAuditDataTableAjaxHandler(model) as JsonResult;
Assert.IsNotNull(result);
}
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 virtual void SetUp()
{
AutomapperConfiguration.Configure();
dataContextMock = MockRepository.GenerateMock <NemeStatsDataContext>();
gameDefinitionRetrieverMock = MockRepository.GenerateMock <IGameDefinitionRetriever>();
gameDefinitionTransformationMock = MockRepository.GenerateMock <IGameDefinitionDetailsViewModelBuilder>();
showingXResultsMessageBuilderMock = MockRepository.GenerateMock <IShowingXResultsMessageBuilder>();
gameDefinitionCreatorMock = MockRepository.GenerateMock <IGameDefinitionSaver>();
urlHelperMock = MockRepository.GenerateMock <UrlHelper>();
boardGameGeekApiClient = MockRepository.GenerateMock <IBoardGameGeekApiClient>();
gameDefinitionControllerPartialMock = MockRepository.GeneratePartialMock <GameDefinitionController>(
dataContextMock,
gameDefinitionRetrieverMock,
gameDefinitionTransformationMock,
showingXResultsMessageBuilderMock,
gameDefinitionCreatorMock,
boardGameGeekApiClient);
gameDefinitionControllerPartialMock.Url = urlHelperMock;
asyncRequestMock = MockRepository.GenerateMock <HttpRequestBase>();
asyncRequestMock.Expect(x => x.Headers)
.Repeat.Any()
.Return(new System.Net.WebHeaderCollection
{
{ "X-Requested-With", "XMLHttpRequest" }
});
var context = MockRepository.GenerateMock <HttpContextBase>();
context.Expect(x => x.Request)
.Repeat.Any()
.Return(asyncRequestMock);
gameDefinitionControllerPartialMock.ControllerContext = new ControllerContext(context, new RouteData(), gameDefinitionControllerPartialMock);
currentUser = new ApplicationUser()
{
Id = "user id",
CurrentGamingGroupId = 15151
};
}
public void Test_ReturnToCaller()
{
NameValueCollection callerUrlParameters = new NameValueCollection {
{ "CallerKey", "CallerValue" }
};
using (_mockRepository.Ordered())
{
using (_mockRepository.Unordered())
{
_pageMock.Expect(mock => mock.GetPostBackCollection()).Return(_postBackCollection);
_pageMock.Expect(mock => mock.SaveAllState());
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
}
//Redirect to external subfunction
_responseMock
.Expect(mock => mock.Redirect(Arg <string> .Matches(arg => arg == "/session/sub.wxe?WxeFunctionToken=" + _subFunction.FunctionToken)))
.WhenCalled(invocation => Thread.CurrentThread.Abort());
//Show external sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(
invocation =>
{
PrivateInvoke.SetNonPublicField(_functionState, "_postBackID", 100);
_pageStep.SetPostBackCollection(new NameValueCollection());
Thread.CurrentThread.Abort();
});
//Return from external sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).Throw(new WxeExecuteNextStepException());
_requestMock.Expect(mock => mock.HttpMethod).Return("GET");
_pageExecutorMock.Expect(mock => mock.ExecutePage(_wxeContext, "~/ThePage", true)).WhenCalled(
invocation =>
{
Assert.That(((IExecutionStateContext)_pageStep).ExecutionState, Is.SameAs(NullExecutionState.Null));
Assert.That(_pageStep.PostBackCollection[WxePageInfo.PostBackSequenceNumberID], Is.EqualTo("100"));
Assert.That(_pageStep.PostBackCollection.AllKeys, Has.Member("Key"));
Assert.That(_pageStep.ReturningFunction, Is.SameAs(_subFunction));
Assert.That(_pageStep.IsReturningPostBack, Is.True);
});
}
_mockRepository.ReplayAll();
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
try
{
//Redirect to external subfunction
WxeReturnOptions returnOptions = new WxeReturnOptions(callerUrlParameters);
_pageStep.ExecuteFunctionExternalByRedirect(new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), returnOptions);
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Show external sub function
_subFunction.Execute();
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Return from external sub function
_subFunction.Execute();
Assert.Fail();
}
catch (WxeExecuteNextStepException)
{
}
Assert.That(_subFunction.ReturnUrl, Is.EqualTo("/session/root.wxe?CallerKey=CallerValue&WxeFunctionToken=" + _rootFunction.FunctionToken));
//Show current page
_pageStep.Execute();
_mockRepository.VerifyAll();
}
public void WhenDebugIsNullOrEmptyInQueryString_NothingShouldHappen()
{
_mockRequest.Expect(r => r.QueryString).Return(new NameValueCollection());
_filter.OnActionExecuted(_mockFilterContext);
_mocks.VerifyAll();
}
