public void Checkout_ReturnsInvoiceOk()
{
// Arrange
var userId = 1;
this.userService.Get("TestUser").Returns(new User {
Id = userId
});
var basket = new Basket();
basket.Add(new BasketItem {
ItemId = 2
});
this.basketService.GetByUserId(userId).Returns(basket);
this.itemService.Get(2).Returns(new Item {
Id = 2, Stock = 4
});
// Act
var actionResult = controller.Checkout("TestUser");
// Assert
Assert.IsInstanceOfType(actionResult, typeof(OkNegotiatedContentResult <Invoice>));
}
public async Task Doing_Checkout_Wit_Basket_Should_Publish_UserCheckoutAccepted_Integration_Event()
{
var fakeCustomerId = "1";
var fakeCustomerBasket = GetCustomerBasketFake(fakeCustomerId);
_basketRepositoryMock.Setup(x => x.GetBasketAsync(It.IsAny <string>()))
.Returns(Task.FromResult(fakeCustomerBasket));
_identityServiceMock.Setup(x => x.GetUserIdentity()).Returns(fakeCustomerId);
var basketController = new BasketController(
_basketRepositoryMock.Object, _identityServiceMock.Object, _serviceBusMock.Object);
basketController.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal(
new ClaimsIdentity(new Claim[] { new Claim("unique_name", "testuser") }))
}
};
//Act
var result = await basketController.Checkout(new BasketCheckout(), Guid.NewGuid().ToString()) as AcceptedResult;
_serviceBusMock.Verify(mock => mock.Publish(It.IsAny <UserCheckoutAcceptedIntegrationEvent>()), Times.Once);
Assert.NotNull(result);
}
public async Task Fazer_Checkout_Com_Basket_Deveria_Publicar_CheckoutEvent()
{
//arrange
var fakeCustomerId = "1";
var fakeCustomerBasket = GetCustomerBasketFake(fakeCustomerId);
_basketRepositoryMock.Setup(x => x.GetBasketAsync(It.IsAny <string>()))
.Returns(Task.FromResult(fakeCustomerBasket))
.Verifiable();
//_identityServiceMock.Setup(x => x.GetUserIdentity()).Returns(fakeCustomerId)
// .Verifiable();
var basketController = new BasketController(
_basketRepositoryMock.Object, _identityServiceMock.Object, _serviceBusMock.Object,
_loggerMock.Object, _configurationMock.Object);
basketController.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = new ClaimsPrincipal(
new ClaimsIdentity(new Claim[] { new Claim("unique_name", "testuser") }))
}
};
//Act
ActionResult <bool> actionResult = await basketController.Checkout(fakeCustomerId, new RegistrationViewModel());
//assert
_serviceBusMock.Verify(mock => mock.Publish(It.IsAny <Messages.Events.CheckoutEvent>(), null), Times.Once);
Assert.NotNull(actionResult);
_basketRepositoryMock.Verify();
//_identityServiceMock.Verify();
}
public void CanCheckoutAndCreateOrder()
{
IRepository <Product> products = new MockContext <Product>();
IRepository <Order> orders = new MockContext <Order>();
IRepository <Customer> customers = new MockContext <Customer>();
MockContext <Basket> baskets = new MockContext <Basket>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.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
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IOrderService orderService = new OrderService(orders);
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "43220"
});
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", 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 CanCheckoutAndCreateOrder()
{
//Setup
IRepository <Basket> baskets = new MockContext <Basket>();
IRepository <Product> products = new MockContext <Product>();
IRepository <Order> orders = new MockContext <Order>();
IRepository <Customer> customers = new MockContext <Customer>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem {
ProductId = "1", Quantity = 2
});
basket.BasketItems.Add(new BasketItem {
ProductId = "2", Quantity = 1
});
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IOrderService orderService = new OrderService(orders);
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "LE3 9RW"
});
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 HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new RouteData(), controller);
Order order = new Order();
controller.Checkout(order);
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()
{
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", 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);
var controller = new BasketController(basketService, orderService);
var httpContext = new MockHttpContext();
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 async void CheckoutReturnBadResult()
{
// Arrange
var userName = "******";
var validShoppingCart = new ShoppingCart();
validShoppingCart.Items = new List <ShoppingCartItem>
{
new ShoppingCartItem
{
Quantity = 1,
// Color = "Red",
Price = 950.00M,
ProductId = "602d2149e773f2a3990b47f5",
ProductName = "IPhone X"
}
};
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync(validShoppingCart);
var basketCheckout = new BasketCheckout
{
UserName = userName,
TotalPrice = 1000
};
//
_mockBasketRepository.Setup(x => x.GetBasket(userName)).ReturnsAsync((ShoppingCart)null);
this.IntialieBasketController();
// Act
var result = await _sut.Checkout(basketCheckout);
// Assert BadRequestResult
Assert.NotNull(result);
var badRequestResult = Assert.IsType <BadRequestResult>(result);
Assert.Equal(400, badRequestResult.StatusCode);
}
public void CanCheckOutAndCreateOrder()
{
//Setup
IRepository <Basket> baskets = new MockContext <Basket>();
IRepository <Product> products = new MockContext <Product>();
IRepository <Order> orders = new MockContext <Order>();
IRepository <Customer> customer = new MockContext <Customer>();
// creacion de productos
products.Insert(new Product("1", "Cosa1", 5));
products.Insert(new Product("2", "Cosa2", 10));
products.Insert(new Product("3", "Cosa3", 15));
// creacion de un cliente
customer.Insert(new Customer("1", "Tony", "Stark", "*****@*****.**", "something", "Los Angeles", "California", "00000"));
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
// insercion de productos en la cesta
Basket basket = new Basket();
basket.BasketItems.Add(new BasketItem("1", "1", 2));
basket.BasketItems.Add(new BasketItem("1", "2", 1));
baskets.Insert(basket);
IBasketService basketService = new BasketService(products, baskets);
IOrderService orderService = new OrderService(orders);
var controller = new BasketController(basketService, orderService, customer);
var httpContext = new HttpMockContext();
httpContext.User = FakeUser;
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
}); // creacion de un contexto para crear y leer cookies
controller.ControllerContext = new System.Web.Mvc.ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller); // añadir el contexto al controlador
//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()
{
var products = new MockContext <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
var baskets = new MockContext <Basket>();
var basket = new Basket();
basket.BasketItems.Add(new BasketItem()
{
ProductId = "1", Quantity = 2
});
basket.BasketItems.Add(new BasketItem()
{
ProductId = "2", Quantity = 1
});
baskets.Insert(basket);
var basketService = new BasketService(products, baskets);
var orders = new MockContext <Order>();
var orderService = new OrderService(orders);
var customers = new MockContext <Customer>();
var controller = new BasketController(basketService, orderService, customers);
var httpContext = new MockHttpContext();
httpContext.Request.Cookies.Add(new HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new RouteData(), controller);
var order = new Order();
var result = controller.Checkout(order);
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
var orderInRepository = orders.Find(order.Id);
Assert.AreEqual(2, orderInRepository.OrderItems.Count);
}
public async Task Doing_Checkout_Without_Basket_Should_Return_Bad_Request()
{
var fakeCustomerId = "2";
_basketRepositoryMock.Setup(x => x.GetBasketAsync(It.IsAny <string>()))
.Returns(Task.FromResult((CustomerBasket)null));
_identityServiceMock.Setup(x => x.GetUserIdentity()).Returns(fakeCustomerId);
//Act
var basketController = new BasketController(
_basketRepositoryMock.Object, _identityServiceMock.Object, _serviceBusMock.Object);
var result = await basketController.Checkout(new BasketCheckout(), Guid.NewGuid().ToString()) as BadRequestResult;
Assert.NotNull(result);
}
public void Checkout_ReturnsBillInTextForm()
{
//Arrange
var mock = new Mock <IProductBasketService>();
mock.Setup(m => m.Checkout()).Returns(billText);
var controller = new BasketController(mock.Object);
//Act
controller.AddProduct("test");
var result = controller.Checkout();
//Assert
result.Value.Should().NotBeNull();
result.Value.Should().Be(billText);
}
public async Task Doing_Checkout_Wit_Basket_Should_Publish_UserCheckoutAccepted_Integration_Event()
{
var fakeCustomerId = "1";
var fakeCustomerBasket = GetCustomerBasketFake(fakeCustomerId);
_basketRepositoryMock.Setup(x => x.GetBasketAsync(It.IsAny <string>()))
.Returns(Task.FromResult(fakeCustomerBasket));
_identityServiceMock.Setup(x => x.GetUserIdentity()).Returns(fakeCustomerId);
//Act
var basketController = new BasketController(
_basketRepositoryMock.Object, _identityServiceMock.Object, _serviceBusMock.Object);
var result = await basketController.Checkout(new BasketCheckout()) as AcceptedResult;
_serviceBusMock.Verify(mock => mock.Publish(It.IsAny <UserCheckoutAcceptedIntegrationEvent>()), Times.Once);
Assert.NotNull(result);
}
public void Cannot_Checkout_Add_SubmitOrder()
{
//Организация
Mock <IOrderProcessor> mock = new Mock <IOrderProcessor>();
Basket basket = new Basket();
basket.AddItem(new Book(), 1);
BasketController controller = new BasketController(null, mock.Object);
ViewResult result = controller.Checkout(basket, new DeliveryDetails());
//Действия
mock.Verify(m => m.ProcessOrder(It.IsAny <Basket>(), It.IsAny <DeliveryDetails>()), Times.Once());
//Утверждение
Assert.AreEqual("Completed", result.ViewName);
Assert.AreEqual(true, result.ViewData.ModelState.IsValid);
}
//проверка на пустую корзину пользователя
public void Cannot_Checkout_Empty_Basket()
{
//Организация
Mock <IOrderProcessor> mock = new Mock <IOrderProcessor>();
Basket basket = new Basket();
DeliveryDetails delivery = new DeliveryDetails();
BasketController controller = new BasketController(null, mock.Object);
ViewResult viewResult = controller.Checkout(basket, delivery);
//Действия
mock.Verify(m => m.ProcessOrder(It.IsAny <Basket>(), It.IsAny <DeliveryDetails>()), Times.Never());
//Утверждение
Assert.AreEqual("", viewResult.ViewName);
Assert.AreEqual(false, viewResult.ViewData.ModelState.IsValid);
}
public async Task Fazer_Checkout_Basket_Not_Found()
{
//Arrange
var fakeCustomerId = "123";
_basketRepositoryMock.Setup(x => x.GetBasketAsync(It.IsAny <string>()))
.ThrowsAsync(new KeyNotFoundException());
var basketController = new BasketController(
_basketRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object,
_loggerMock.Object,
_configurationMock.Object);
RegistrationViewModel input = new RegistrationViewModel();
//Act
ActionResult <bool> actionResult = await basketController.Checkout(fakeCustomerId, input);
//Assert
Assert.IsType <NotFoundResult>(actionResult.Result);
}
//проверка на пустую корзину пользователя
public void Cannot_Checkout_Invalid_ShippingDetails()
{
//Организация
Mock <IOrderProcessor> mock = new Mock <IOrderProcessor>();
Basket basket = new Basket();
basket.AddItem(new Book(), 1);
BasketController controller = new BasketController(null, mock.Object);
controller.ModelState.AddModelError("error", "error");
ViewResult viewResult = controller.Checkout(basket, new DeliveryDetails());
//Действия
mock.Verify(m => m.ProcessOrder(It.IsAny <Basket>(), It.IsAny <DeliveryDetails>()), Times.Never());
//Утверждение
Assert.AreEqual("", viewResult.ViewName);
Assert.AreEqual(false, viewResult.ViewData.ModelState.IsValid);
}
public async Task Fazer_Checkout_Sem_Cesta_Deve_Retornar_BadRequest()
{
//Arrange
var fakeCustomerId = "2";
var basketController = new BasketController(
_basketRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object,
_loggerMock.Object,
_configurationMock.Object);
RegistrationViewModel input = new RegistrationViewModel();
basketController.ModelState.AddModelError("Email", "Required");
//Act
ActionResult <bool> actionResult = await basketController.Checkout(fakeCustomerId, input);
//Assert
BadRequestObjectResult badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(actionResult.Result);
Assert.IsAssignableFrom <SerializableError>(badRequestObjectResult.Value);
}
public void CanCheckoutAndCreateOrder()
{
var customers = new MockContext <Customer>();
var products = new MockContext <Product>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
var baskets = new MockContext <Basket>();
var 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);
var basketService = new BasketService(products, baskets);
var orders = new MockContext <Order>();
var orderService = new OrderService(orders);
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "4350"
});
var 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 HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new ControllerContext(httpContext, new System.Web.Routing.RouteData(), controller);
// Act
var order = new Order();
controller.Checkout(order);
// Assert
Assert.AreEqual(2, order.OrderItems.Count);
Assert.AreEqual(0, basket.BasketItems.Count);
var 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 CheckoutAndCreateOrder()
{
// Arrange
var basketItems = new List <BasketItemViewModel>
{
new BasketItemViewModel
{
Id = "1",
Quantity = 2,
ProductName = "P1",
Price = 10.00m
},
new BasketItemViewModel
{
Id = "2",
Quantity = 1,
ProductName = "P2",
Price = 5.00m
}
};
_basketService.Setup(x => x.GetBasketItems(It.IsAny <HttpContext>())).Returns(basketItems);
var order = new Order();
_orderService.Setup(x => x.CreateOrder(order, basketItems));
var customer = new Customer
{
Id = "1",
Email = "*****@*****.**",
City = "Stockholm"
};
_customerRepository.Setup(x => x.Add(customer));
var claims = new List <Claim>()
{
new Claim(ClaimTypes.Name, customer.Email),
new Claim(ClaimTypes.NameIdentifier, "1"),
new Claim("name", customer.Email),
};
var identity = new ClaimsIdentity(claims, "TestAuthType");
var claimsPrincipal = new ClaimsPrincipal(identity);
_mockPrincipal.Setup(x => x.Identity).Returns(identity);
_mockPrincipal.Setup(x => x.IsInRole(It.IsAny <string>())).Returns(true);
var mockHttpContext = new Mock <HttpContext>();
mockHttpContext.Setup(m => m.User).Returns(claimsPrincipal);
var context = new ControllerContext
{
HttpContext = mockHttpContext.Object
};
// Then set it to controller before executing test
_sut.ControllerContext = context;
// Act
var result = _sut.Checkout(order);
// Assert
Assert.Equal("Payment Processed", order.OrderStatus);
_basketService.Verify(x => x.GetBasketItems(It.IsAny <HttpContext>()), Times.Once);
Assert.Equal(2, _basketService.Object.GetBasketItems(It.IsAny <HttpContext>()).Count);
_orderService.Verify(x => x.CreateOrder(order, basketItems), Times.Once);
_basketService.Verify(x => x.ClearBasket(It.IsAny <HttpContext>()), Times.Once);
// Act
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("ThankYou", redirectToActionResult.ActionName);
// Assert
}
public void CanCheckoutAndCreateOrderTest()
{
IRepository <Product> product_context = new MockRepository <Product>();
IRepository <Basket> basket_context = new MockRepository <Basket>();
IRepository <Order> order_context = new MockRepository <Order>();
IRepository <Customer> customer_context = new MockRepository <Customer>();
product_context.Insert(new Product()
{
id = "1", price = 10.00m
});
product_context.Insert(new Product()
{
id = "2", price = 5.00m
});
product_context.Insert(new Product()
{
id = "3", price = 10.00m
});
Basket basket = new Basket();
basket.basketItems.Add(new BasketItem()
{
product_id = "1", quantity = 2, BasketId = basket.id
});
basket.basketItems.Add(new BasketItem()
{
product_id = "2", quantity = 2, BasketId = basket.id
});
basket_context.Insert(basket);
IBasketService basketService = new BasketService(product_context, basket_context);
IOrderService orderService = new OrderService(order_context);
customer_context.Insert(new Customer()
{
id = "1", email = "*****@*****.**"
});
IPrincipal fake_user = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
BasketController basketController = new BasketController(basketService, orderService, customer_context);
var httpContext = new MockHttpContext();
httpContext.Request.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.id
});
httpContext.User = fake_user;
basketController.ControllerContext = new ControllerContext(httpContext, new System.Web.Routing.RouteData(), basketController);
Order order = new Order();
basketController.Checkout(order);
Assert.AreEqual(2, order.orderItems.Count);
Assert.AreEqual(0, basket.basketItems.Count);
Order order1 = order_context.Find(order.id);
Assert.AreEqual(2, order1.orderItems.Count);
}
public void CanCheckoutAndCreateOrder()
{
IRepository <Product> products = new MockContext <Product>();
IRepository <Customer> customers = new MockContext <Customer>();
products.Insert(new Product()
{
Id = "1", Price = 10.00m
});
products.Insert(new Product()
{
Id = "2", Price = 11.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);
//Fake user email
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "57000"
});
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("wappBasket")
{
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);//To check whether the item in repo or not
}
public void CanCheckoutAndCreateOrder()
{
// Arrange
IRepository <Product> productContext = new MockContext <Product>();
productContext.Insert(new Product()
{
Id = "1", Price = 10.00m, Name = "Product1"
});
productContext.Insert(new Product()
{
Id = "2", Price = 5.00m
});
IRepository <Basket> basketContext = 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
});
basketContext.Insert(basket);
IRepository <BasketItem> basketItemsContext = new MockContext <BasketItem>();
IRepository <Order> orderContext = new MockContext <Order>();
IRepository <Customer> customerContext = new MockContext <Customer>();
customerContext.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", ZipCode = "12345"
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
IBasketService basketService = new BasketService(productContext, basketContext, basketItemsContext);
IOrderService orderService = new OrderService(orderContext);
BasketController controller = new BasketController(basketService, orderService, customerContext);
MockHttpContext httpContext = new MockHttpContext();
httpContext.User = FakeUser;
httpContext.Response.Cookies.Add(new System.Web.HttpCookie("eCommerceBasket")
{
Value = basket.Id
});
controller.ControllerContext = new System.Web.Mvc.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 = orderContext.Find(order.Id);
Assert.AreEqual(10.00m, orderInRep.OrderItems.ToList().FirstOrDefault().Price);
Assert.AreEqual(2, orderInRep.OrderItems.ToList().FirstOrDefault().Quantity);
Assert.AreEqual("Product1", orderInRep.OrderItems.ToList().FirstOrDefault().ProductName);
}
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);
}
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 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()
{
IRepository <Product> products = new MockContext <Product>(); // created a mock Product repository
products.Insert(new Product()
{
Id = "1", Price = 10.00m
}); // added products with an Id and Price so we can check the Id and calculations
products.Insert(new Product()
{
Id = "2", Price = 5.00m
});
IRepository <Basket> baskets = new MockContext <Basket>(); // mock Basket repo
Basket basket = new Basket();
// created two basket items
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 <Order> orders = new MockContext <Order>();
IOrderService orderService = new OrderService(orders); // created an order service with our two items and
IRepository <Customer> customers = new MockContext <Customer>();
customers.Insert(new Customer()
{
Id = "1", Email = "*****@*****.**", Zipcode = "66021"
});
IPrincipal FakeUser = new GenericPrincipal(new GenericIdentity("*****@*****.**", "Forms"), null);
var controller = new BasketController(basketService, orderService, customers); // passed it thru the controller
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); // expects order to be checked in
//Assert
Assert.AreEqual(2, order.OrderItems.Count); // makes sure we have two items in our order
Assert.AreEqual(0, basket.BasketItems.Count); // makes sure basket items are empty
Order orderInRepo = orders.Find(order.Id); // retrieve the order from the repo
Assert.AreEqual(2, orderInRepo.OrderItems.Count); // makes sure we have two orders in our repo
}
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);
}
