public void Index_RegisterUserWithDifferentPassword_ExceptionCompare()
{
//init
var controller = DependencyResolver.Current.GetService<Areas.Default.Controllers.UserController>();
var httpContext = new MockHttpContext().Object;
ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);
controller.ControllerContext = context;
//act
var registerUserView = new UserView()
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
AvatarPath = "/file/no-image.jpg",
BirthdateDay = 1,
BirthdateMonth = 12,
BirthdateYear = 1987,
Captcha = "1111"
};
try
{
Validator.ValidateObject<UserView>(registerUserView);
}
catch (Exception ex)
{
Assert.IsInstanceOf<ValidatorException>(ex);
Assert.IsInstanceOf<System.ComponentModel.DataAnnotations.CompareAttribute>(((ValidatorException)ex).Attribute);
}
}
public void CreateUser_Create100Users_NoAssert()
{
var repository = DependencyResolver.Current.GetService<IRepository>();
var controller = DependencyResolver.Current.GetService<LessonProject.Areas.Default.Controllers.UserController>();
var httpContext = new MockHttpContext().Object;
var route = new RouteData();
route.Values.Add("controller", "User");
route.Values.Add("action", "Register");
route.Values.Add("area", "Default");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "1111");
var rand = new Random((int)DateTime.Now.Ticks);
for (int i = 0; i < 100; i++)
{
var registerUserView = new UserView()
{
ID = 0,
Email = Email.GetRandom(Name.GetRandom(), Surname.GetRandom()),
Password = "******",
ConfirmPassword = "******",
Captcha = "1111",
BirthdateDay = rand.Next(28) + 1,
BirthdateMonth = rand.Next(12) + 1,
BirthdateYear = 1970 + rand.Next(20)
};
controller.Register(registerUserView);
}
}
public void Setup()
{
resolver = new DefaultUrlResolver();
var httpContext = new MockHttpContext();
httpContext.HttpRequest.Setup(x => x.Url).Returns(new Uri("http://foo.com/fake/path"));
context = new TestController(httpContext).ControllerContext;
}
public void CreateUser_CreateNormalUser_CountPlusOne()
{
var repository = DependencyResolver.Current.GetService<IRepository>();
var controller = DependencyResolver.Current.GetService<webTemplate.Areas.Default.Controllers.UserController>();
var countBefore = repository.Users.Count();
var httpContext = new MockHttpContext().Object;
var route = new RouteData();
route.Values.Add("controller", "User");
route.Values.Add("action", "Register");
route.Values.Add("area", "Default");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "1111");
var registerUserView = new RegisterUserView()
{
ID = 0,
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
Captcha = "1111",
};
Validator.ValidateObject<RegisterUserView>(registerUserView);
controller.Register(registerUserView);
var countAfter = repository.Users.Count();
Assert.AreEqual(countBefore + 1, countAfter);
}
public void SomeTest()
{
var fakeContext = new MockHttpContext();
UsersController controller = new UsersController();
fakeContext.SetFakeControllerContext(controller);
controller.Show("abc");
fakeContext.MockResponse.Verify(x => x.Redirect(It.IsAny<string>()));
}
public void Construction()
{
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
HttpContextBase httpContext = new MockHttpContext();
InjectorFactory services = new InjectorFactory();
Assert.IsNotNull(services);
ContentManager manager = new ContentManager(writer, httpContext, services);
Assert.IsNotNull(manager);
manager.Dispose();
manager = null;
manager = new ContentManager(writer, httpContext, services);
TextWriter contentWriter = manager.ContentWriter;
Assert.IsNotNull(contentWriter);
Assert.IsInstanceOfType(contentWriter, typeof(StringWriter));
}
public void Index_AskForDefaultPage_GetViewResult()
{
var controller = DependencyResolver.Current.GetService<webTemplate.Areas.Default.Controllers.HomeController>();
var route = new RouteData();
route.Values.Add("controller", "Home");
route.Values.Add("action", "Index");
route.Values.Add("area", "Default");
var httpContext = new MockHttpContext().Object;
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
var controllerActionInvoker = new FakeControllerActionInvoker<ViewResult>();
var result = controllerActionInvoker.InvokeAction(controller.ControllerContext, "Index");
}
public void Index_NotAuthorizeGetDefaultView_RedirectToLoginPage()
{
var auth = DependencyResolver.Current.GetService<IAuthentication>();
auth.LogOut();
var httpContext = new MockHttpContext(auth).Object;
var controller = DependencyResolver.Current.GetService<Areas.Admin.Controllers.HomeController>();
var route = new RouteData();
route.Values.Add("controller", "Home");
route.Values.Add("action", "Index");
route.Values.Add("area", "Admin");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
var controllerActionInvoker = new FakeControllerActionInvoker<HttpUnauthorizedResult>();
var result = controllerActionInvoker.InvokeAction(controller.ControllerContext, "Index");
}
public void Create_HttpContext()
{
var context = new MockHttpContext();
// Create proxy, verify it's not null.
var proxy = DomainServiceProxy.Create<IMockDomainServiceContract, MockDomainService>(context);
Assert.IsNotNull(proxy);
// Examine its Context property
PropertyInfo contextProp = proxy.GetType().GetProperty("Context");
DomainServiceContext proxyContext = (DomainServiceContext)contextProp.GetGetMethod().Invoke(proxy, null);
Assert.AreSame(context, proxyContext.GetService(typeof(HttpContextBase)));
// Examine its DomainServiceType property
PropertyInfo typeProp = proxy.GetType().GetProperty("DomainServiceType");
Type proxyType = (Type)typeProp.GetGetMethod().Invoke(proxy, null);
Assert.AreEqual(typeof(MockDomainService), proxyType);
}
public void Index_AdminAuthorize_GetViewResult()
{
var auth = DependencyResolver.Current.GetService<IAuthentication>();
auth.Login("admin", "password", false);
var httpContext = new MockHttpContext(auth).Object;
var controller = DependencyResolver.Current.GetService<Areas.Admin.Controllers.HomeController>();
var route = new RouteData();
route.Values.Add("controller", "Home");
route.Values.Add("action", "Index");
route.Values.Add("area", "Admin");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
var controllerActionInvoker = new FakeControllerActionInvoker<ViewResult>();
var result = controllerActionInvoker.InvokeAction(controller.ControllerContext, "Index");
}
public void Register_CaptchaIsInCorrect_Fail()
{
var httpContext = new MockHttpContext().Object;
var controller = DependencyResolver.Current.GetService<Areas.Default.Controllers.UserController>();
var route = new RouteData();
route.Values.Add("controller", "User");
route.Values.Add("action", "Register");
route.Values.Add("area", "Default");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "1112");
var registerUserView = new RegisterUserView()
{
ID = 0,
Captcha = "1111"
};
controller.Register(registerUserView);
}
public void Index_AskForDefaultPage_GetViewResult()
{
var auth = DependencyResolver.Current.GetService<IAuthentication>();
var controller = DependencyResolver.Current.GetService<webTemplate.Areas.Admin.Controllers.UserController>();
auth.Login("admin");
var route = new RouteData();
route.Values.Add("controller", "User");
route.Values.Add("action", "Index");
route.Values.Add("area", "Admin");
var values = new FakeValueProvider();
values["page"] = 2;
var httpContext = new MockHttpContext(auth).Object;
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
var controllerActionInvoker = new FakeControllerActionInvoker<ViewResult>(values);
var result = controllerActionInvoker.InvokeAction(controller.ControllerContext, "Index");
}
public async Task discovery_attribute___validationerror_urlbindingerror_specified_no_replacements()
{
base.SetupEnvironment();
var request = @$ "
GET https://{host}/discovery/attribute/validationerror/specified/custom/no/replacements?CustomInt=abc HTTP/1.1
Host: {host}
Authorization: Token {staticToken}
Accept: {applicationJson}";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: base.uriBindingErrorStatusCode,
shouldHaveResponse: true,
expectedAuthenticatedBy: AuthenticationType.Provider,
expectedAuthorizedBy: AuthorizationType.Provider,
expectedContentType: applicationJson,
expectedValidationState: ApiValidationState.NotAttempted,
extendedHeaders: new NameValuePairs <string, string>
{
});
var data = await base.GetResponseData <CommonErrorResponse>(response).ConfigureAwait(false);
data.Should().NotBeNull();
data.Messages.Should().NotBeNull();
data.Messages.Should().HaveCount(1);
data.Messages[0].ErrorMessageStr.Should().Be("uriBindingError-test");
}
public void GivenAValidUserAndPasswordAndPasswordHasExpired_WhenILogin_ThenIGetRedirectedToTheChangePasswordPage()
{
var userMock = new Mock <ApplicationUser>();
this.userService.Setup(m => m.GetApplicationUser("username", "password")).Returns(userMock.Object);
userMock.SetupGet(u => u.IsApproved).Returns(true);
userMock.SetupGet(u => u.IsLockedOut).Returns(false);
this.userService.Setup(x => x.CheckForPassRenewal(It.IsAny <DateTime>(), It.IsAny <DateTime>())).Returns(true);
MockHttpContext.SetupGet(x => x.Session["LastLoggedInDate"]).Returns(_sessionValue);
var result =
this.sessionController.Create(new LoginUserViewModel {
Username = "******", Password = "******"
}, string.Empty) as
RedirectToRouteResult;
this.userService.Verify(m => m.GetApplicationUser(It.IsAny <String>(), It.IsAny <String>()), Times.AtLeastOnce);
this.userService.Verify(x => x.CheckForPassRenewal(It.IsAny <DateTime>(), It.IsAny <DateTime>()), Times.AtLeastOnce);
result.Should().NotBeNull();
result.RouteValues["controller"].Should().Be("Account");
result.RouteValues["action"].Should().Be("ChangePassword");
}
public async Task multimethods___should_return_for_configured_methods_with_request_body(string method)
{
base.SetupEnvironment();
var request = @$ "
{method} https://{host}/pipeline/multiple/methods HTTP/1.1
Host: {host}
Accept: {applicationJson}
Content-Type: {applicationJson}
{{
" "Value" ": " "MyValue" "
}}";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 200,
expectedContentType: applicationJson,
expectedContentLength: 19,
shouldHaveResponse: true,
expectedValidationState: ApiValidationState.Succeeded,
extendedHeaders: new NameValuePairs <string, string>
{
});
var data = await base.GetResponseData <MultiMethodsModel>(response).ConfigureAwait(false);
data.Should().NotBeNull();
data.Value.Should().Be("MyValue");
}
public void CreateUser_CreateNormalUser_CountPlusOne()
{
var repository = DependencyResolver.Current.GetService <IRepository>();
var controller = DependencyResolver.Current.GetService <sexivirt.Web.Areas.Default.Controllers.UserController>();
var countBefore = repository.Users.Count();
var httpContext = new MockHttpContext().Object;
var route = new RouteData();
route.Values.Add("controller", "User");
route.Values.Add("action", "Register");
route.Values.Add("area", "Default");
ControllerContext context = new ControllerContext(new RequestContext(httpContext, route), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "1111");
var registerUserView = new RegisterUserView()
{
ID = 0,
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
};
Validator.ValidateObject <RegisterUserView>(registerUserView);
controller.Register(registerUserView);
var countAfter = repository.Users.Count();
Assert.AreEqual(countBefore + 1, countAfter);
}
public async Task notimplemented___has_response_with_headers()
{
base.SetupEnvironment();
var request = @$ "
GET https://{host}/helper/responses/notimplemented/headers HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {applicationJson}
";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 501,
shouldHaveResponse: true,
allowCustom500Response: true,
expectedContentType: applicationJson,
expectedValidationState: ApiValidationState.Succeeded,
extendedHeaders: new NameValuePairs <string, string>
{
{ "Test", "Value" }
});
var data = await base.GetResponseData <HelperResponseModel>(response).ConfigureAwait(false);
data.Should().NotBeNull();
data.Value.Should().Be("Test");
}
public async Task authentication___anonymous_head_with_no_authentication_header()
{
base.SetupEnvironment();
var request = @$ "
HEAD https://{host}/authentication/anonymous/allowed HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {applicationJson}";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 200,
shouldHaveResponse: true,
expectedContentType: applicationJson,
expectedValidationState: ApiValidationState.Succeeded,
expectedAuthenticationResult: true,
expectedAuthenticatedBy: Auth.AuthenticationType.Anonymous,
expectedAuthenticationScheme: null,
expectedAuthenticationValue: null,
expectedContentLength: 16,
extendedHeaders: new NameValuePairs <string, string>
{
});
var data = await base.GetResponseData <AuthenticatedModel>(response).ConfigureAwait(false);
data.Should().BeNull();
}
public void CanAddBasketItem()
{
IRepository <Basket> baskets = new MockContext <Basket>();
IRepository <Product> products = new MockContext <Product>();
IRepository <Order> orders = new MockContext <Order>();
var httpContext = new MockHttpContext();
IBasketService basketService = new BasketService(products, baskets);
IOrderService orderService = new OrderService(orders);
var controller = new BasketController(basketService, orderService);
controller.ControllerContext = new System.Web.Mvc.ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
// basketService.AddToBasket(httpContext, "1");
controller.AddToBasket("1");
Basket basket = baskets.Collection().FirstOrDefault();
Assert.IsNotNull(basket);
Assert.AreEqual(1, basket.BasketItems.Count());
Assert.AreEqual("1", basket.BasketItems.ToList().FirstOrDefault().ProductId);
}
public void CanAddCartItems()
{
IRepository <Cart> carts = new MockContext <Cart>();
IRepository <Product> products = new MockContext <Product>();
IRepository <Order> orders = new MockContext <Order>();
IRepository <Customer> customers = new MockContext <Customer>();
var httpContext = new MockHttpContext();
ICartService cartService = new CartService(products, carts);
IOrderService orderService = new OrderService(orders);
var controller = new CartController(cartService, orderService, customers);
controller.ControllerContext = new System.Web.Mvc.ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
controller.addToCart("i");
Cart cart = carts.Collection().FirstOrDefault();
Assert.IsNotNull(cart);
Assert.AreEqual(1, cart.CartItems.Count);
Assert.AreEqual("i", cart.CartItems.ToList().FirstOrDefault().ProductId);
}
public void WhenISubmitTheChangeCurrentPasswordPage_AndTheModelIsValid_ItShouldReturnTheRightViewAndContainTheModel()
{
MockHttpContext.SetupGet(x => x.User.Identity.Name).Returns("testUser");
var model = new ChangeCurrentPasswordModel();
var user = new ApplicationUser();
this.userService.Setup(x => x.ChangePassword(It.IsAny <String>(), It.IsAny <String>(), It.IsAny <String>()));
this.userService.Setup(x => x.GetApplicationUserById(It.IsAny <String>())).Returns(user);
this.userService.Setup(x => x.SignIn(user, false));
this.userService.Setup(x => x.UpdateUserLastLogindate(It.IsAny <String>()));
var result = this.controller.ChangeCurrent(model) as RedirectToRouteResult;
result.Should().NotBeNull();
result.Should().BeOfType <RedirectToRouteResult>();
this.userService.Verify(x => x.ChangePassword(It.IsAny <String>(), It.IsAny <String>(), It.IsAny <String>()), Times.AtLeastOnce);
this.userService.Verify(x => x.GetApplicationUserById(It.IsAny <String>()), Times.AtLeastOnce);
this.userService.Verify(x => x.SignIn(user, false), Times.AtLeastOnce);
this.userService.Verify(x => x.UpdateUserLastLogindate(It.IsAny <String>()), Times.AtLeastOnce);
result.RouteValues["controller"].Should().Be("Home");
result.RouteValues["action"].Should().Be("Index");
}
public async Task serviceunavailable___null_response_with_errors()
{
base.SetupEnvironment();
var request = @$ "
GET https://{host}/helper/responses/serviceunavailable/null/with/errors HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {applicationJson}
";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 503,
shouldHaveResponse: true,
allowCustom500Response: true,
expectedContentType: applicationJson,
expectedValidationState: ApiValidationState.Succeeded,
extendedHeaders: new NameValuePairs <string, string>
{
});
var data = await base.GetResponseData <CommonErrorResponse>(response).ConfigureAwait(false);
data.Should().NotBeNull();
data.Messages.Should().NotBeNull();
data.Messages[0].ErrorMessageStr.Should().Be("Test-Error");
}
public async Task discovery_attribute___validationerror_urlbindingvalueerror_defaults_correctly()
{
base.SetupEnvironment();
var request = @$ "
GET https://{host}/discovery/attribute/validationerror/default?queryValue=abc HTTP/1.1
Host: {host}
Authorization: Token {staticToken}
Accept: {applicationJson}";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: base.uriBindingErrorStatusCode,
shouldHaveResponse: true,
expectedAuthenticatedBy: AuthenticationType.Provider,
expectedAuthorizedBy: AuthorizationType.Provider,
expectedContentType: applicationJson,
expectedValidationState: ApiValidationState.NotAttempted,
extendedHeaders: new NameValuePairs <string, string>
{
});
var data = await base.GetResponseData <CommonErrorResponse>(response).ConfigureAwait(false);
data.Should().NotBeNull();
data.Messages.Should().NotBeNull();
data.Messages.Should().HaveCount(1);
data.Messages[0].ErrorMessageStr.Should().Be("Uri type conversion for 'queryValue' with value 'abc' could not be converted to type Nullable`1.");
}
public async Task accept___json_successful(string accept, string exectedContentType)
{
base.SetupEnvironment();
var request = @$ "
GET https://{host}/formatters/accept HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {accept}
";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 200,
expectedContentType: exectedContentType,
shouldHaveResponse: true,
expectedContentLength: 358,
expectedValidationState: ApiValidationState.Succeeded,
extendedHeaders: new NameValuePairs <string, string>
{
});
var data = await base.GetResponseData <SimpleUrlBindingRs>(response).ConfigureAwait(false);
data.Should().NotBeNull();
data.BoolVar.Should().BeTrue();
}
public void Index_RegisterUserWithWrongCaptcha_ModelStateWithError()
{
//init
var controller = DependencyResolver.Current.GetService<Areas.Default.Controllers.UserController>();
var httpContext = new MockHttpContext().Object;
ControllerContext context = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);
controller.ControllerContext = context;
controller.Session.Add(CaptchaImage.CaptchaValueKey, "2222");
//act
var registerUserView = new UserView()
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******",
AvatarPath = "/file/no-image.jpg",
BirthdateDay = 1,
BirthdateMonth = 12,
BirthdateYear = 1987,
Captcha = "1111"
};
var result = controller.Register(registerUserView);
Assert.AreEqual("Текст с картинки введен неверно", controller.ModelState["Captcha"].Errors[0].ErrorMessage);
}
public void GiveAJobController_WhenIWantTheJobReportListAndEnvironmentValueIsEmpty_ThenAnExceptionIsThrown()
{
MockHttpContext.Setup(m => m.Session["Environment"]).Returns(String.Empty);
this.jobsController.GetJobReportList(It.IsAny <String>(), It.IsAny <String>());
}
public void SetUp()
{
_ctx = new MockHttpContext();
}
public void Setup()
{
context = new MockHttpContext();
controller = new TestController(context);
response = new SagePayResponse();
result = new ValidOrderResult("foo", response);
}
public void GivenADocumentController_WhenICallItsSearchCriteraMethod_AndThereAreDocumentsThatHaveBeenRejected_ThenItReturnsTheCorrectView()
{
_controller = new DocumentController(
_documentService.Object,
_userService.Object,
_manCoService.Object,
_logger.Object);
DateTime rejectedDate = DateTime.Now;
_userService.Setup(x => x.GetApplicationUser()).Returns(new ApplicationUser());
_manCoService.Setup(x => x.GetManCosByUserId(It.IsAny <string>())).Returns(new List <ManCo>());
_documentService.Setup(d => d.GetDocument(It.IsAny <string>())).Returns(new Document()
{
Rejection = new Rejection
{
RejectedBy = "user",
RejectionDate = rejectedDate
}
});
_documentService.Setup(
d =>
d.GetDocuments(
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <List <string> >(),
It.IsAny <string>(),
It.IsAny <DateTime?>(),
It.IsAny <DateTime?>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <DateTime?>(),
It.IsAny <DateTime?>(),
It.IsAny <string>())).Returns(_documentsIndexed);
SetControllerContext(_controller);
MockHttpContext.SetupGet(x => x.Session["SearchViewModel"]).Returns(null);
var result = (ViewResult)_controller.Search(new SearchViewModel());
_userService.Verify(x => x.GetApplicationUser(), Times.Once);
_manCoService.Verify(x => x.GetManCosByUserId(It.IsAny <string>()), Times.Once);
result.Model.Should().BeOfType <DocumentsViewModel>();
var model = (DocumentsViewModel)result.Model;
model.Documents.Should().OnlyContain(d => d.RejectedBy == "user");
model.Documents.Should().OnlyContain(d => d.RejectionDate == rejectedDate);
_controller.TempData.Should().NotBeNull();
_controller.TempData["valid"].Should().Be("Show filter");
}
public void Setup()
{
result = new ErrorResult();
context = new MockHttpContext();
controller = new TestController(context);
}
public async Task method_not_found_for_get_route_with_enabled_head_should_return_405(string method)
{
base.SetupEnvironment();
var request = @$ "
{method} https://{host}/method/not/found HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: */*
Referer: https://www.google.com/
Accept-Language: en-US,en;q=0.9
";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 405,
shouldHaveResponse: false,
expectedValidationState: ApiValidationState.NotAttempted,
extendedHeaders: new NameValuePairs <string, string>
{
{ "Allow", "GET, PUT, HEAD" }
});
var data = await base.GetResponseData <MethodNotFoundModel>(response).ConfigureAwait(false);
data.Should().BeNull();
}
[Theory]
[InlineData("POST")]
[InlineData("TRACE")]
[InlineData("DELETE")]
[InlineData("OPTIONS")]
[InlineData("PATCH")]
[InlineData("HEAD")]
public async Task method_not_found_for_get_route_with_no_head_should_return_405(string method)
{
base.SetupEnvironment();
var request = @$ "
{method} https://{host}/method/not/found/nohead HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: */*
Referer: https://www.google.com/
Accept-Language: en-US,en;q=0.9
";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 405,
shouldHaveResponse: false,
expectedValidationState: ApiValidationState.NotAttempted,
extendedHeaders: new NameValuePairs <string, string>
{
{ "Allow", "GET, PUT" }
});
var data = await base.GetResponseData <MethodNotFoundModel>(response).ConfigureAwait(false);
data.Should().BeNull();
}
public void BaseIntegrationSetUp()
{
HttpContext = new MockHttpContext();
Container.Register <HttpContextBase>(c => HttpContext.Object);
}
public void Setup() {
result = new TransactionNotFoundResult("foo");
context = new MockHttpContext();
controller = new TestController(context);
}
public async Task enablehead___should_return_matching_response_when_default_enabled_for_get()
{
base.SetupEnvironment();
var request = @$ "
GET https://{host}/head/configured/default HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {applicationJson}
";
using var httpContext = new MockHttpContext(this.ServiceProvider, request);
var apiContext = await Invoke(httpContext).ConfigureAwait(false);
var response = httpContext.Response;
base.AssertResponse(
apiContext: apiContext,
response: response,
expectedHttpStatus: 200,
expectedContentType: applicationJson,
shouldHaveResponse: true,
expectedValidationState: ApiValidationState.Succeeded,
extendedHeaders: new NameValuePairs <string, string>
{
});
var data = await base.GetResponseData <RequestHeadModel>(response).ConfigureAwait(false);
data.Should().NotBeNull();
data.Configured.Should().BeTrue();
base.SetupEnvironment();
request = @$ "
HEAD https://{host}/head/configured/default HTTP/1.1
Host: {host}
Connection: keep-alive
User-Agent: UnitTest/1.0 DEV
Accept: {applicationJson}";
using var httpContextHead = new MockHttpContext(this.ServiceProvider, request);
var headApiContext = await Invoke(httpContextHead).ConfigureAwait(false);
var headResponse = httpContextHead.Response;
base.AssertResponse(
apiContext: headApiContext,
response: headResponse,
expectedHttpStatus: 200,
shouldHaveResponse: true,
expectedContentType: applicationJson,
expectedValidationState: ApiValidationState.Succeeded,
expectedContentLength: apiContext.Response.ContentLength,
extendedHeaders: new NameValuePairs <string, string>
{
});
headApiContext.Response.ContentLength.Should().Be(apiContext.Response.ContentLength);
headApiContext.Response.Headers.Count.Should().Be(apiContext.Response.Headers.Count);
headResponse.Headers.Count.Should().Be(response.Headers.Count);
foreach (var headHeader in headApiContext.Response.Headers)
{
var resHeader = apiContext.Response.Headers.FirstOrDefault(h => h.Name == headHeader.Name);
resHeader.Should().NotBeNull();
if (headHeader.Name != "X-RequestId" && headHeader.Name != "X-CorrelationId" && headHeader.Name != "Date" && headHeader.Name != "Expires")
{
resHeader.Value.Should().Be(headHeader.Value);
}
else
{
resHeader.Value.Should().NotBeNullOrWhiteSpace();
}
}
foreach (var resHeader in apiContext.Response.Headers)
{
var headHeader = headApiContext.Response.Headers.FirstOrDefault(h => h.Name == resHeader.Name);
headHeader.Should().NotBeNull();
if (resHeader.Name != "X-RequestId" && resHeader.Name != "X-CorrelationId" && resHeader.Name != "Date" && resHeader.Name != "Expires")
{
headHeader.Value.Should().Be(resHeader.Value);
}
else
{
headHeader.Value.Should().NotBeNullOrWhiteSpace();
}
}
data = await base.GetResponseData <RequestHeadModel>(headResponse).ConfigureAwait(false);
data.Should().BeNull();
}
public void CanCheckOutAndCreateOrder()
{
IRepository <Customer> customers = new MockContext <Customer>();
IRepository <Product> products = new MockContext <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 2.00m
});
IRepository <Cart> carts = new MockContext <Cart>();
Cart cart = new Cart();
cart.CartItems.Add(new CartItem()
{
ProductId = "1", Quantity = 2, CartId = cart.Id
});
cart.CartItems.Add(new CartItem()
{
ProductId = "2", Quantity = 1, CartId = cart.Id
});
carts.Insert(cart);
ICartService cartService = new CartService(products, carts);
IRepository <Order> orders = new MockContext <Order>();
IOrderService orderService = new OrderService(orders);
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "123"
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "forms"), null);
var controller = new CartController(cartService, orderService, customers);
var httpContext = new MockHttpContext();
httpContext.User = FakeUser;
httpContext.Request.Cookies.Add(new HttpCookie("eCommercecart")
{
Value = cart.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new RouteData(), controller);
//Act
Order order = new Order();
controller.Checkout(order);
//Assert
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, cart.CartItems.Count);
Order orderInRep = orders.Find(order.Id);
Assert.AreEqual(2, orderInRep.OrderItems.Count);
}
public void CanCheckoutAndCreateOrder()
{
// setup
IRepository <Customer> customers = new MockContext <Customer>();
IRepository <Product> products = new MockContext <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 50.00m
});
IRepository <Basket> baskets = new MockContext <Basket>();
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quantity = 2, BasketId = basket.Id
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quantity = 1, BasketId = basket.Id
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IRepository <Order> orders = new MockContext <Order>();
IOrderService orderService = new OrderService(orders); // this is the repository added for this test
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "90210"
}); // added fake user to the context
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
var controller = new BasketController(basketService, orderService, customers); // dependency injection
var httpContext = new MockHttpContext();
httpContext.User = FakeUser;
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new RouteData(), controller);
// Act
Order order = new Order();
controller.Checkout(order);
// Assert
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
Order orderInRep = orders.Find(order.Id);
Assert.AreEqual(2, orderInRep.OrderItems.Count);
}
public void CanCheckoutAndCreateOrder()
{
IRepositorio <Cliente> customers = new MockContext <Cliente>();
IRepositorio <Producto> products = new MockContext <Producto>();
products.Insertar(new Producto()
{
Id = "1", Precio = 10.00m
});
products.Insertar(new Producto()
{
Id = "2", Precio = 5.00m
});
IRepositorio <Cesta> baskets = new MockContext <Cesta>();
Cesta basket = new Cesta();
basket.ItemsCesta.Add(new ItemCesta()
{
IdProducto = "1", Cantidad = 2, IdCesta = basket.Id
});
basket.ItemsCesta.Add(new ItemCesta()
{
IdProducto = "1", Cantidad = 1, IdCesta = basket.Id
});
baskets.Insertar(basket);
ISCesta basketService = new SCesta(products, baskets);
IRepositorio <OrdenEnvio> orders = new MockContext <OrdenEnvio>();
ISOrden orderService = new SOrden(orders);
customers.Insertar(new Cliente()
{
Id = "1", CorreoCliente = "*****@*****.**", CodigoPostalCliente = "90210"
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
var controller = new CestaController(basketService, orderService, customers);
var httpContext = new MockHttpContext();
httpContext.User = FakeUser;
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
//Act
OrdenEnvio order = new OrdenEnvio();
controller.Comprar(order);
//assert
Assert.AreEqual(2, order.ItemsOrden.Count);
Assert.AreEqual(0, basket.ItemsCesta.Count);
OrdenEnvio orderInRep = orders.Buscar(order.Id);
Assert.AreEqual(2, orderInRep.ItemsOrden.Count);
}
public void CanGetSummaryModel()
{
IRepository <Basket> baskets = new MockContext <Basket>();
IRepository <Product> products = new MockContext <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
products.Insert(new Product()
{
Id = "3", Price = 15.00m
});
products.Insert(new Product()
{
Id = "4", Price = 20.00m
});
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quantity = 2
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "2", Quantity = 1
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "3", Quantity = 3
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "4", Quantity = 4
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IRepository <Customer> cusutomers = new MockContext <Customer>();
IRepository <Order> orders = new MockContext <Order>();
IOrderService orderService = new OrderService(orders);
var controller = new BasketController(basketService, orderService, cusutomers);
var httpContext = new MockHttpContext();
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new System.Web.Mvc.ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
var results = controller.BasketSummary() as PartialViewResult;
var basketSummary = (BasketSumaryViewModel)results.ViewData.Model;
Assert.AreEqual(10, basketSummary.BasketCount);
Assert.AreEqual(150.00m, basketSummary.BasketTotal);
}
public void CanCheckoutAndCreateOrder()
{
// Product
IRepository <Customer> customers = new MockContext <Customer>(); // Customer
IRepository <Product> products = new MockContext <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
// Basket
IRepository <Basket> baskets = new MockContext <Basket>();
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quanity = 2, BasketId = basket.Id
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quanity = 1, BasketId = basket.Id
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
// Order
IRepository <Order> orders = new MockContext <Order>();
IOrderService orderService = new OrderService(orders);
// Customer
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", Code = "7850"
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null); // Db
// Controller
var controller = new BasketController(basketService, orderService, customers);
// Fake context cookies
var httpContext = new MockHttpContext();
// Manually cookie
httpContext.User = FakeUser; // Customer
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
// Finally
controller.ControllerContext = new ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
// Act
Order order = new Order();
controller.Checkout(order);
// Assert
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count); // Clear - empty
// Retrive the order
Order orderInRep = orders.Find(order.Id);
Assert.AreEqual(2, orderInRep.OrderItems.Count);
}
public void CanCheckoutAndCreateOrder()
{
//Setup
IRepository <Product> products = new MockRepository <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
IRepository <Basket> baskets = new MockRepository <Basket>();
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quantity = 2, BasketId = basket.Id
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "2", Quantity = 1, BasketId = basket.Id
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IRepository <Customer> customers = new MockRepository <Customer>();
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "90210"
});
IRepository <Order> orders = new MockRepository <Order>();
IOrderService orderService = new OrderService(orders);
var controller = new BasketController(basketService, orderService, customers);
var httpContext = new MockHttpContext();
httpContext.Request.Cookies.Add(new HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
httpContext.User = FakeUser;
controller.ControllerContext = new ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
Order order = new Order();
//Act
controller.Checkout(order);
//Assert
//Test our actual order object
Assert.AreEqual(2, order.orderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
//then confirm the db has also been updated.
Order orderInRepo = orders.Find(order.Id);
Assert.AreEqual(2, orderInRepo.orderItems.Count);
}
ContentManager CreateContentManager(StringBuilder sb)
{
StringWriter writer = new StringWriter(sb);
HttpContextBase httpContext = new MockHttpContext();
InjectorFactory services = new InjectorFactory();
Assert.IsNotNull(services);
ContentManager manager = new ContentManager(writer, httpContext, services);
Assert.IsNotNull(manager);
return manager;
}
public void Setup() {
result = new InvalidSignatureResult("foo");
context = new MockHttpContext();
controller = new TestController(context);
}
private static MockHttpContext GetHttpContext(bool isAuthenticated, int userId)
{
var mockContext = new MockHttpContext(userId, isAuthenticated);
return(mockContext);
}
public void CanCheckoutAndCreateOrder()
{
IRepository <Product> products = new MockContext <Product>();//Creates a mock product repo
products.Insert(new Product()
{
Id = "1", Price = 10.00m
}); //Creates a dummy product to be added to be tested only need Id and Price BC those are the only things considered for calc
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
IRepository <Basket> baskets = new MockContext <Basket>();
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quantity = 2, BasketId = basket.Id
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "2", Quantity = 1, BasketId = basket.Id
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IRepository <Customer> customers = new MockContext <Customer>();
IRepository <Order> orders = new MockContext <Order>();
IOrderService orderService = new OrderService(orders);
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "15767"
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
var controller = new BasketController(basketService, orderService, customers);
var httpContext = new MockHttpContext();
httpContext.User = FakeUser;
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
//Act
Order order = new Order();
controller.Checkout(order);
//Assert
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
Order orderInRep = orders.Find(order.Id);
Assert.AreEqual(2, orderInRep.OrderItems.Count);
}
public void TestInjector(IInjector instanceToTest, string expected)
{
MockHttpContext context = new MockHttpContext();
string result = instanceToTest.GetContent(context);
Assert.AreEqual(expected, result);
}
public TestController(MockHttpContext context)
{
ControllerContext = new ControllerContext(context.Object, new RouteData(), this);
}
public void CanCheckoutAndCreateOrder()
{
IRepository <ProductModel> products = new MockContext <ProductModel>();
IRepository <BasketModel> baskets = new MockContext <BasketModel>();
IRepository <OrderModel> orders = new MockContext <OrderModel>();
IRepository <CustomerModel> customers = new MockContext <CustomerModel>();
products.Insert(new ProductModel()
{
Id = "1", Price = 10.00m
});
products.Insert(new ProductModel()
{
Id = "2", Price = 5.00m
});
BasketModel basket = new BasketModel();
basket.BasketItems.Add(new BasketItemModel()
{
ProductId = "1", Quantity = 2, BasketId = basket.Id
});
basket.BasketItems.Add(new BasketItemModel()
{
ProductId = "2", Quantity = 1, BasketId = basket.Id
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IOrderService orderService = new OrderService(orders);
var httpContext = new MockHttpContext();
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket", basket.Id));
customers.Insert(new CustomerModel()
{
Id = "1", Email = "*****@*****.**", ZipCode = "123456"
});
IPrincipal fakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
httpContext.User = fakeUser;
var controller = new BasketController(basketService, orderService, customers);
controller.ControllerContext = new System.Web.Mvc.ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
// Act.
OrderModel order = new OrderModel();
controller.Checkout(order);
// Assert.
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
OrderModel orderInRep = orders.Find(order.Id);
Assert.AreEqual(2, orderInRep.OrderItems.Count);
}
public void CanCheckoutAndCreateOrder()
{
//Arrange
IRepository <Product> productRepository = new MockRepository <Product>();
IRepository <Basket> basketRepository = new MockRepository <Basket>();
IRepository <Customer> customerRepository = new MockRepository <Customer>();
productRepository.Insert(new Product()
{
Id = "1", Price = 10.00m
});
productRepository.Insert(new Product()
{
Id = "2", Price = 5.00m
});
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quantity = 2, BasketId = basket.Id
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "2", Quantity = 1, BasketId = basket.Id
});
basketRepository.Insert(basket);
IBasketService basketService = new BasketService(productRepository, basketRepository);
IRepository <Order> orderRepository = new MockRepository <Order>();
IOrderService orderService = new OrderService(orderRepository);
customerRepository.Insert(new Customer()
{
Id = "1",
Email = "*****@*****.**",
ZipCode = "4824"
});
IPrincipal fakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
var controller = new BasketController(basketService, orderService, customerRepository);
MockHttpContext httpContext = new MockHttpContext();
httpContext.User = fakeUser;
httpContext.Request.Cookies.Add(new HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new RouteData(), controller);
//Act
Order order = new Order();
controller.Checkout(order);
//Assert
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
Order orderInRep = orderRepository.Find(order.Id);
Assert.AreEqual(2, orderInRep.OrderItems.Count);
}
public void GivenADocumentController_WhenICallItsSearchCriteriaMethodForPageTwo_ThenItRetrunsTheCorrectNumberOfDocuments()
{
var documentsPageTwo = new PagedResult <IndexedDocumentData>
{
CurrentPage = 2,
ItemsPerPage = 10,
TotalItems = 50,
Results = new[]
{
new IndexedDocumentData()
{
MappedIndexes = new List <IndexMapped> {
}
},
new IndexedDocumentData()
{
MappedIndexes = new List <IndexMapped> {
}
},
new IndexedDocumentData()
{
MappedIndexes = new List <IndexMapped> {
}
}
}
};
_controller = new DocumentController(
_documentService.Object,
_userService.Object,
_manCoService.Object,
_logger.Object);
_userService.Setup(x => x.GetApplicationUser()).Returns(new ApplicationUser());
_manCoService.Setup(x => x.GetManCosByUserId(It.IsAny <string>())).Returns(new List <ManCo>());
_documentService.Setup(
d =>
d.GetDocuments(
2,
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <List <string> >(),
It.IsAny <string>(),
It.IsAny <DateTime?>(),
It.IsAny <DateTime?>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <DateTime?>(),
It.IsAny <DateTime?>(),
It.IsAny <string>())).Returns(documentsPageTwo);
SetControllerContext(_controller);
MockHttpContext.SetupGet(x => x.Session["SearchViewModel"]).Returns(null);
var result = (ViewResult)_controller.Search(new SearchViewModel(), 2);
_userService.Verify(x => x.GetApplicationUser(), Times.Once);
_manCoService.Verify(x => x.GetManCosByUserId(It.IsAny <string>()), Times.Once);
var model = (DocumentsViewModel)result.Model;
int documentCount = (from s in _documentsIndexed.Results select s).Count();
model.Documents.Should().HaveCount(documentCount);
}
public void TestMockHttpContext()
{
// Instantiate the view directly
var view = new MockHttpContext();
// Set up the data that needs to be access by the view
var mockHttpRequest = new Mock<HttpRequestBase>(MockBehavior.Loose);
mockHttpRequest.Setup(m => m.IsAuthenticated).Returns(true);
// Render it in an HtmlDocument
var output = view.RenderAsHtml(new HttpContextBuilder().With(mockHttpRequest.Object).Build());
// Verify that it looks correct
var element = output.GetElementbyId("user-authenticated");
Assert.IsNotNull(element);
}
public void CanCheckoutAndCreateOrder()
{
IRepository <Customer> customers = new MockContext <Customer>();
IRepository <Product> products = new MockContext <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
IRepository <Basket> baskets = new MockContext <Basket>();
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quanity = 2, BasketId = basket.Id
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quanity = 1, BasketId = basket.Id
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IRepository <Order> orders = new MockContext <Order>();
IOrderService orderService = new OrderService(orders);
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "76201"
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
var controller = new BasketController(basketService, orderService, customers);
var httpContext = new MockHttpContext();
httpContext.User = FakeUser;
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
//Act
Order order = new Order();
controller.Checkout(order);
//assert
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
Order orderInRep = orders.Find(order.Id);
Assert.AreEqual(2, orderInRep.OrderItems.Count);
}
public void BaseIntegrationSetUp()
{
HttpContext = new MockHttpContext();
Container.Register<HttpContextBase>(c => HttpContext.Object);
}
