private ShoppingCartController GetShoppingCartController()
{
var controller = new ShoppingCartController(_databaseContext, new ShoppingCartLogic(_databaseContext));
HttpContextStub.SetupController(controller);
return(controller);
}
protected void ClearButton1_Click(object sender, EventArgs e)
{
var username = User.Identity.Name;
SecurityController securitymgr = new SecurityController();
int?employeeid = securitymgr.GetCurrentUserEmployeeId(username);
EmployeeController sysmgrs = new EmployeeController();
Employee info = sysmgrs.Employee_Get(employeeid.Value);
int employeeID = info.EmployeeID;
MessageUserControl.TryRun(() =>
{
ShoppingCartController sysmgr = new ShoppingCartController();
sysmgr.ClearButton_Shopping(employeeID);
List <ShoppingCart> datainfo = sysmgr.ShoppingCart_OrderList();
CartSalesGridView.DataSource = datainfo;
AddButtonn.Enabled = true;
//InvoiceIDText.Text = null;
//InvoiceIDText.Visible = false;
CartSalesGridView.Enabled = true;
CartSalesGridView.DataBind();
QuantityTextBox.Text = "1";
PanelInvoice.Visible = false;
CategoryDDL.Enabled = true;
ProductDDL.Enabled = true;
}, "Empty", "Shopping Cart is Empty Now");
}
public void TestDecreaseAmountOnProductLine()
{
// Arrange
var context = new Mock <ControllerContext>();
var session = new MockHttpSession();
List <ProductLine> productLineList = new List <ProductLine>();
ShoppingCartController cartController = new ShoppingCartController();
cartController.ControllerContext = context.Object;
Product product = new Product();
product.ProductId = 1;
product.Price = 100;
ProductLine productLine = new ProductLine();
productLine.Amount = 1;
productLine.Product = product;
productLineList.Add(productLine);
session.insertIntoDictionary("shoppingCart", productLineList);
context.Setup(m => m.HttpContext.Session).Returns(session);
// Act
cartController.Add(product);
cartController.DecreaseAmount(productLine.Product.ProductId);
// Assert
Assert.AreEqual(1, productLine.Amount);
}
private static ShoppingCartController GetShoppingCartController(IConfiguration config)
{
var controller = new ShoppingCartController(new DatabaseContext(config));
HttpContextStub.SetupController(controller);
return(controller);
}
public virtual async Task Can_add_items_to_cart()
{
const string cartId = "CartId_A";
using var context = CreateContext();
await context.Database.CreateExecutionStrategy().ExecuteAsync(
async() =>
{
using (Fixture.BeginTransaction(context))
{
var albums = CreateTestAlbums(
10,
new Artist {
Name = "Kung Fu Kenny"
}, new Genre {
Name = "Rap"
});
context.AddRange(albums);
context.SaveChanges();
var controller = new ShoppingCartController(context, cartId);
var albumId = albums[2].AlbumId;
await controller.AddToCart(albumId);
var cart = ShoppingCart.GetCart(context, cartId);
Assert.Single(await cart.GetCartItems());
Assert.Equal(albumId, (await cart.GetCartItems()).Single().AlbumId);
}
});
}
//TEST: SHOPPINGCART_ORDERNOW_TEST
//Test the functionality of the ShoppingCart OrderNow method using test data.
public void ShoppingCart_OrderNow_Test()
{
//ARRANGE
ShoppingCartController shoppingCartController = new ShoppingCartController();
MyDataEntities db = new MyDataEntities();
//Grab the test User and test Product objects and find both of their IDs
var productArray = db.Products.Where(x => x.ProductName == "testProduct").ToList();
var userArray = db.Users.Where(x => x.UserName == "testRegisterUser").ToList();
int testProductID = 0;
foreach (var item in productArray)
{
testProductID = item.ProductID;
}
int testUserID = 0;
foreach (var item in userArray)
{
testUserID = item.UserID;
}
//ACT
ActionResult result = shoppingCartController.TestOrderNow(testProductID, testUserID);
//ASSERT
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(RedirectResult));
}
public void ReturnEmptyCart_WhenThereIsNotAnyProduct()
{
// Arrange
var mockControllerContext = new Mock <ControllerContext>();
var mockSession = new Mock <HttpSessionStateBase>();
mockSession.SetupGet(s => s["cart"]).Returns(null);
mockControllerContext.Setup(p => p.HttpContext.Session).Returns(mockSession.Object);
var productServiceMock = new Mock <IProductService>();
var orderServiceMock = new Mock <IOrderService>();
var orderDetailsServiceMock = new Mock <IOrderDetailsService>();
var contactInfoServiceMock = new Mock <IContactInfoService>();
var userServiceMock = new Mock <IUserService>();
var sizeServiceMock = new Mock <ISizeService>();
ShoppingCartController shoppingCartController = new ShoppingCartController(
productServiceMock.Object,
orderServiceMock.Object,
orderDetailsServiceMock.Object,
contactInfoServiceMock.Object,
userServiceMock.Object,
sizeServiceMock.Object);
shoppingCartController.ControllerContext = mockControllerContext.Object;
// Act & Assert
shoppingCartController
.WithCallTo(s => s.MyCart())
.ShouldRenderView("EmptyCart");
}
public ShoppingCartServiceTest()
{
_mockRepo = new Mock <IShoppingCartServiceAdapter>();
_mockRepoProducts = new Mock <IProductsServiceAdapter>();
_controller = new ShoppingCartController(_mockRepo.Object, _mockRepoProducts.Object);
_controllerProducts = new ProductController(_mockRepoProducts.Object);
}
public void TestCreate()
{
var session = new MockHttpSession();
var context = new Mock <HttpContextBase>();
context.Setup(c => c.Session).Returns(session);
var controller = new ShoppingCartController();
controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
var db = new CsK24T25Entities();
var product = db.SANPHAMs.First();
var result = controller.Create(product.MASP, 2) as RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.AreEqual("Index", result.RouteValues["action"]);
var shoppingCart = session["ShoppingCart"] as List <CHITIETDONHANG>;
Assert.IsNotNull(shoppingCart);
Assert.AreEqual(1, shoppingCart.Count);
Assert.AreEqual(product.MASP, shoppingCart.First().SANPHAM.MASP);
Assert.AreEqual(2, shoppingCart.First().SOLUONG);
}
public void RemoveShoppingCartItem_Throws_ForUnknownItem()
{
var shoppingCartRepository = new MockShoppingCartRepository();
shoppingCartRepository.GetByIdDelegate = (userId) =>
{
return(new ShoppingCart(new Collection <ShoppingCartItem>()));
};
shoppingCartRepository.RemoveItemFromCartDelegate = (shoppingCart, itemId) =>
{
return(false);
};
var target = new ShoppingCartController(shoppingCartRepository, new MockProductRepository());
try
{
target.RemoveShoppingCartItem("JohnDoe", "UnknownProductid");
}
catch (HttpResponseException ex)
{
Assert.AreEqual(System.Net.HttpStatusCode.NotFound, ex.Response.StatusCode);
}
}
public async Task Can_add_items_to_cart()
{
const string cartId = "CartId_A";
const int albumId = 3;
using (var context = CreateContext())
{
using (Fixture.BeginTransaction(context))
{
var albums = CreateTestAlbums(
10,
new Artist
{
ArtistId = 1, Name = "Kung Fu Kenny"
}, new Genre
{
GenreId = 1, Name = "Rap"
});
context.AddRange(albums);
context.SaveChanges();
var controller = new ShoppingCartController(context, cartId);
await controller.AddToCart(albumId);
var cart = ShoppingCart.GetCart(context, cartId);
Assert.Single(await cart.GetCartItems());
Assert.Equal(albumId, (await cart.GetCartItems()).Single().AlbumId);
}
}
}
public void TestCreate()
{
var session = new MockHttpSession();
var context = new Mock <HttpContextBase>();
context.Setup(c => c.Session).Returns(session);
var controller = new ShoppingCartController();
controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
var db = new CS4PEntities();
var product = db.Products.First();
var result = controller.Create(product.id, 2) as RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.AreEqual("Index", result.RouteValues["action"]);
var shoppingCart = session["ShoppingCart"] as List <BillDetail>;
Assert.IsNotNull(shoppingCart);
Assert.AreEqual(1, shoppingCart.Count);
Assert.AreEqual(product.id, shoppingCart.First().Product.id);
Assert.AreEqual(2, shoppingCart.First().Quantity);
}
public void ShoppingCartIndex_WithProducts_DisplaysProducts()
{
var mockCustomerRepo = new Mock <ICustomerRepo>();
var mockStoreRepo = new Mock <IStoreRepo>();
var mockProductRepo = new Mock <IProductRepo>();
var mockOrderRepo = new Mock <IOrderRepo>();
var mockShoppingCartRepo = new Mock <IShoppingCart>();
Dictionary <int, int> keyValuePairs = new Dictionary <int, int>()
{
{ 1, 10 },
};
mockShoppingCartRepo.Setup(r => r.GetCart())
.Returns(keyValuePairs);
mockProductRepo.Setup(r => r.GetProductById(It.IsAny <int>()))
.Returns(new Product(1, "Product", 10.00M));
var controller = new ShoppingCartController(new NullLogger <ShoppingCartController>(), mockStoreRepo.Object, mockCustomerRepo.Object, mockOrderRepo.Object, mockProductRepo.Object, mockShoppingCartRepo.Object);
IActionResult actionResult = controller.Index();
var viewResult = Assert.IsAssignableFrom <ViewResult>(actionResult);
var products = Assert.IsAssignableFrom <IEnumerable <ProductViewModel> >(viewResult.Model);
var productsList = products.ToList();
Assert.Equal(1, productsList.Count());
Assert.Equal("Product", productsList[0].Name);
Assert.Equal(10.00M, productsList[0].Price);
Assert.Null(viewResult.ViewName);
}
public async Task Return_Ok()
{
// Given
var cartItemReturnModel = new ReturnModel <ShoppingCartItem>()
{
Result = new ReturnResult {
Status = ReturnStatus.Success
}
};
var model = new ShoppingCartSave
{
ProductId = 1
};
var shoppingCartItemServiceMock = new Mock <IShoppingCartItemService>();
shoppingCartItemServiceMock.Setup(x => x.SaveCartItemAsync(model)).Returns(Task.FromResult(cartItemReturnModel));
var controller = new ShoppingCartController(shoppingCartItemServiceMock.Object);
// When
var result = await controller.Post(model);
// Assertions
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
}
public async Task Customer_Null_BadRequest()
{
// Given
var returnModel = new ReturnModel <int>();
var model = new ShoppingCartSave
{
CustomerInfo = new CustomerInfo
{
CustomerId = 1
}
};
var productServiceMock = new Mock <IProductService>();
var shoppingCartItemRepositoryMock = new Mock <IRepository <ShoppingCartItem> >();
var customerServiceMock = new Mock <ICustomerService>();
customerServiceMock.Setup(x => x.CheckCustomer(model.CustomerInfo.CustomerId.Value)).Returns(Task.FromResult(returnModel));
var service = new ShoppingCartItemService(productServiceMock.Object, customerServiceMock.Object, shoppingCartItemRepositoryMock.Object);
var controller = new ShoppingCartController(service);
// When
var result = await controller.Post(model);
// Assertions
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
}
protected void AddToCart_ItemCommand(object sender, ListViewCommandEventArgs e)
{
int stockitemid = int.Parse(e.CommandArgument.ToString());
ApplicationUserManager userManager = new ApplicationUserManager(new
UserStore <ApplicationUser>(new ApplicationDbContext()));
string userName = Context.User.Identity.GetUserName();
int employeeid = 0;
if (!string.IsNullOrEmpty(userName))
{
employeeid = userManager.Get_CurrentEmployeeIDFromUserName(userName);
}
int qty = 0;
int.TryParse((e.Item.FindControl("QuantitySelected") as TextBox).Text, out qty);
if (qty < 1)
{
MessageUserControl.ShowInfo("Could not add item to shopping cart. Quantity must be greater than zero.");
}
else
{
MessageUserControl.TryRun(() =>
{
ShoppingCartController sysmgr = new ShoppingCartController();
sysmgr.Add_ProductToShoppingCart(employeeid, stockitemid, qty);
}, "Product Added", "The product has been added to your cart.");
}
}
protected void CheckoutButton_Click(object sender, EventArgs e)
{
MainView.ActiveViewIndex = 2;
ApplicationUserManager userManager = new ApplicationUserManager(new
UserStore <ApplicationUser>(new ApplicationDbContext()));
string userName = Context.User.Identity.GetUserName();
int employeeid = 0;
if (!string.IsNullOrEmpty(userName))
{
employeeid = userManager.Get_CurrentEmployeeIDFromUserName(userName);
UserName3.Text = userName;
UserID3.Text = employeeid.ToString();
}
CheckoutGridView.DataBind();
ShoppingCartController sysmgr = new ShoppingCartController();
List <CartSelection> cartItems = sysmgr.Get_CartItemsByEmployeeID(employeeid);
decimal subTotal = cartItems.Sum(x => x.QuantitySelected * x.SellingPrice);
SubTotalLabel.Text = subTotal.ToString();
decimal tax = subTotal / 20;
TaxLabel.Text = tax.ToString();
decimal discount = Label3.Visible ? decimal.Parse(DiscountLabel.Text) : 0;
decimal total = subTotal + tax - discount;
TotalLabel.Text = total.ToString();
}
public void CallGetShoppingCart_WhenParametersAreNotNull()
{
// Arrange
Mock <IShoppingCart> shoppingCartMock = new Mock <IShoppingCart>();
Mock <ICartIdentifier> cartIdentifierMock = new Mock <ICartIdentifier>();
Mock <HttpContextBase> httpContextBaseMock = new Mock <HttpContextBase>();
Mock <ShoppingCartViewModel> shoppingCartViewModel = new Mock <ShoppingCartViewModel>();
var id = Guid.NewGuid().ToString();
var cartItemsList = new List <ICart>()
{
new Cart()
{
CoffeeId = "ESP",
CoffeeCost = 3.24m,
Count = 1,
CoffeeDescription = "Grande Espresso",
ShoppingCartId = id
}
};
cartIdentifierMock.Setup(m => m.GetCardId(It.IsAny <HttpContextBase>())).Returns(id);
shoppingCartMock.Setup(m => m.GetShoppingCart(It.IsAny <string>())).Returns(shoppingCartMock.Object);
shoppingCartMock.Setup(m => m.GetCartItems()).Returns(cartItemsList);
shoppingCartMock.Setup(m => m.GetTotal()).Returns(cartItemsList.Select(c => c.Count * c.CoffeeCost).Sum());
ShoppingCartController shoppingCartController = new ShoppingCartController(shoppingCartMock.Object, cartIdentifierMock.Object);
//Act
shoppingCartController.Index();
// Assert
shoppingCartMock.Verify(m => m.GetShoppingCart(It.IsAny <string>()), Times.Once());
}
public void ReturnCart_WhenThereIsProducts()
{
// Arrange
var controllerContextMock = new Mock <ControllerContext>();
var sessionMock = new Mock <HttpSessionStateBase>();
var productServiceMock = new Mock <IProductService>();
var orderServiceMock = new Mock <IOrderService>();
var orderDetailsServiceMock = new Mock <IOrderDetailsService>();
var contactInfoServiceMock = new Mock <IContactInfoService>();
var userServiceMock = new Mock <IUserService>();
var sizeServiceMock = new Mock <ISizeService>();
ShoppingCartController shoppingCartController = new ShoppingCartController(
productServiceMock.Object,
orderServiceMock.Object,
orderDetailsServiceMock.Object,
contactInfoServiceMock.Object,
userServiceMock.Object,
sizeServiceMock.Object);
shoppingCartController.CartItems = new List <OrderDetailViewModel>();
sessionMock.SetupGet(s => s["cart"]).Returns(shoppingCartController.CartItems);
controllerContextMock.Setup(p => p.HttpContext.Session).Returns(sessionMock.Object);
shoppingCartController.ControllerContext = controllerContextMock.Object;
// Act & Assert
shoppingCartController
.WithCallTo(s => s.MyCart())
.ShouldRenderView("MyCart");
}
public virtual async Task Cart_has_items_once_they_have_been_added()
{
const string cartId = "CartId_A";
using var context = CreateContext();
await context.Database.CreateExecutionStrategy().ExecuteAsync(
async() =>
{
using (Fixture.BeginTransaction(context))
{
var cartItems = CreateTestCartItems(
cartId,
itemPrice: 10,
numberOfItems: 5);
context.AddRange(cartItems.Select(n => n.Album).Distinct());
context.AddRange(cartItems);
context.SaveChanges();
var controller = new ShoppingCartController(context, cartId);
var viewModel = await controller.Index();
Assert.Equal(5, viewModel.CartItems.Count);
Assert.Equal(5 * 10, viewModel.CartTotal);
}
});
}
private ShoppingCartController GetShoppingCartController()
{
var controller = new ShoppingCartController();
HttpContextStub.SetupController(controller);
return(controller);
}
public static async Task <ObservableCollection <Rental> > GetCartAsync()
{
using (HttpResponseMessage response = await ShoppingCartController.GetCart())
{
int status = (int)response.StatusCode;
string body = await response.Content.ReadAsStringAsync();
if (status == 200)
{
ObservableCollection <Rental> jsonBody = JsonConvert.DeserializeObject <ObservableCollection <Rental> >(body);
return(jsonBody);
}
else if (status == 400)
{
throw new ArgumentException(body);
}
else if (status == 401)
{
throw new UnauthenticatedException();
}
else if (status == 404)
{
return(new ObservableCollection <Rental>());
}
else if (status == 500)
{
throw new ServerException();
}
else
{
throw new Exception("An error occurred");
}
}
}
public void TestCourseSchedule()
{
//Arrange
var sr = new ScheduleRequest();
sr.Months = null;
sr.States = null;
sr.Zip = null;
sr.Miles = null;
sr.PCodes = null;
sr.PageStart = 1;
sr.PageLimit = 10;
var json = JsonConvert.SerializeObject(sr);
//construct content to send
var content = new System.Net.Http.StringContent(json, Encoding.UTF8, "application/json");
var request = new HttpRequestMessage {
RequestUri = new Uri("http://localhost/api/shoppingcart"),
Content = content
};
var controller = new ShoppingCartController();
//Set a fake request. If your controller creates responses you will need this
controller.Request = request;
//Act
// Call the controller method and test if the return data is correct.
var response = controller.CourseSchedule(request) as OkNegotiatedContentResult <List <EventSyncResponse> >;
//Assert
//...other asserts
}
public virtual async Task RemoveFromCart_removes_items_from_cart()
{
const string cartId = "CartId_A";
const int numberOfItems = 5;
const int unitPrice = 10;
using var context = CreateContext();
await context.Database.CreateExecutionStrategy().ExecuteAsync(
async() =>
{
using (Fixture.BeginTransaction(context))
{
var cartItems = CreateTestCartItems(cartId, unitPrice, numberOfItems);
context.AddRange(cartItems.Select(n => n.Album).Distinct());
context.AddRange(cartItems);
context.SaveChanges();
var controller = new ShoppingCartController(context, cartId);
var cartItemId = cartItems[2].CartItemId;
var viewModel = await controller.RemoveFromCart(cartItemId);
Assert.Equal(numberOfItems - 1, viewModel.CartCount);
Assert.Equal((numberOfItems - 1) * 10, viewModel.CartTotal);
Assert.Equal("Greatest Hits has been removed from your shopping cart.", viewModel.Message);
var cart = ShoppingCart.GetCart(context, cartId);
Assert.DoesNotContain((await cart.GetCartItems()), c => c.CartItemId == cartItemId);
}
});
}
public async Task AddCartItemTest()
{
ShoppingCartItem item = new(12, "ProductName", "Description", new Money("Currency", 4532.15m));
var items = Task.FromResult((IEnumerable<ShoppingCartItem>)new[] { item });
_productCatalog.Setup(t => t.GetShoppingCartItems(new[] { 12 })).Returns(items);
//_eventStore.Setup(t => t.Raise("ShoppingCartItemAdded", new { Id = 124, item })).Returns(0uL);
_eventStore.Setup(t => t.Raise("ShoppingCartItemAdded", It.IsAny<object>())).Returns(0uL);
var shoppingCart = new ShoppingCart(124, Array.Empty<ShoppingCartItem>());
_shoppingCartStore.Setup(t => t.Get(124)).Returns(Task.FromResult(shoppingCart));
_shoppingCartStore.Setup(t => t.Save(It.IsAny<ShoppingCart>())).Returns(Task.CompletedTask);
var request = new Mock<HttpRequest>();
// request.Setup(x => x.Scheme).Returns("http");
// request.Setup(x => x.Host).Returns(HostString.FromUriComponent("http://localhost:8080"));
// request.Setup(x => x.PathBase).Returns(PathString.FromUriComponent("/api"));
var httpContext = Mock.Of<HttpContext>(_ => _.Request == request.Object);
var controllerContext = new ControllerContext { HttpContext = httpContext };
var controller = new ShoppingCartController(_logger.Object, _shoppingCartStore.Object, _productCatalog.Object, _eventStore.Object)
{
ControllerContext = controllerContext,
};
var response = await controller.Post(124, new[] { 12 });
Assert.AreEqual(200, (response as StatusCodeResult)?.StatusCode);
}
public CcWidgetController(IProductService productService,
IOrderService orderService,
ICcService ccService,
IShoppingCartService cartService,
IWorkContext workContext,
IStoreContext storeContext,
IProductAttributeService productAttributeService,
ISettingService settingService,
IPictureService pictureService,
IProductAttributeParser productAttributeParser,
IShoppingCartService shoppingCartService,
IWebHelper webHelper,
ISpecificationAttributeService specificationAttributeService,
IDownloadService downloadService,
ILocalizationService localizationService)
{
_productService = productService;
_orderService = orderService;
_ccService = ccService;
_cartService = cartService;
_workContext = workContext;
_storeContext = storeContext;
_productAttributeService = productAttributeService;
_settingService = settingService;
_pictureService = pictureService;
_productAttributeParser = productAttributeParser;
_shoppingCartService = shoppingCartService;
_customersCanvasSettings = settingService.LoadSetting <CcSettings>();
_webHelper = webHelper;
_specificationAttributeService = specificationAttributeService;
_shoppingCartController = EngineContext.Current.Resolve <ShoppingCartController>();
_downloadService = downloadService;
_localizationService = localizationService;
}
protected void AddButtonn_Click(object sender, EventArgs e)
{
CartSalesGridView.Enabled = true;
PanelPaymentButtons.Visible = true;
Product products = new Product();
products.QuantityOnOrder = int.Parse(QuantityTextBox.Text);
if (string.IsNullOrEmpty(CategoryDDL.SelectedValue) || string.IsNullOrEmpty(ProductDDL.SelectedValue))
{
MessageUserControl.ShowInfo("Required Data", "Please Select Category and Product");
}
else if (CategoryDDL.SelectedIndex == 0)
{
MessageUserControl.ShowInfo("Please Select a Category");
}
//else if(ProductDDL.SelectedIndex == 0)
//{
// MessageUserControl.ShowInfo("Please Select a Product");
//}
else if (products.QuantityOnOrder <= 0)
{
MessageUserControl.ShowInfo("Required Data", "Please Enter Quantity, Should be greater or equal 1");
PanelPaymentButtons.Visible = false;
}
else
{
string category = CategoryDDL.SelectedValue;
int qty = int.Parse(QuantityTextBox.Text);
int productid = int.Parse(ProductDDL.SelectedValue);
var username = User.Identity.Name;
SecurityController securitymgr = new SecurityController();
int?employeeid = securitymgr.GetCurrentUserEmployeeId(username);
EmployeeController sysmgrs = new EmployeeController();
Employee info = sysmgrs.Employee_Get(employeeid.Value);
int employeeID = info.EmployeeID;
MessageUserControl.TryRun(() =>
{
ShoppingCartController sysmgr = new ShoppingCartController();
sysmgr.Add_ItemToCart(employeeID, productid, qty);
List <ShoppingCart> datainfo = sysmgr.ShoppingCart_OrderList();
CartSalesGridView.DataSource = datainfo;
CartSalesGridView.DataBind();
}, "Adding Item", "Item has been added to the cart");
var controller = new ShoppingCartController();
var countTotal = controller.ShoppingCart_OrderList();
SubtotalText.Text = countTotal.Sum(x => x.Quantity * x.Price).ToString("C");
TaxText.Text = countTotal.Sum(t => t.Quantity * t.Price * decimal.Parse(0.05.ToString())).ToString("C");
TotalText.Text = countTotal.Sum(tos => tos.Quantity * tos.Price * decimal.Parse(0.05.ToString()) + (tos.Quantity * tos.Price)).ToString("C");
}
}
public void Setup()
{
mockPieRepository = new Mock <IPieRepository>();
mockShoppingCartRepository = new Mock <IShoppingCartRepository>();
mockCakeRepository = new Mock <ICakeRepository>();
mockUserManger = new Mock <UserManager <IdentityUser> >();
shoppingCartController = new ShoppingCartController(mockPieRepository.Object, mockCakeRepository.Object, mockShoppingCartRepository.Object);
}
public void ShoppingCartController_AddItem_ShouldRedirect() {
ShoppingCartController controller = new ShoppingCartController(cartService, catalogService);
ActionResult result=controller.AddItem(1);
//we should get a redirect here
Assert.IsInstanceOfType(result, typeof(ActionRedirectResult));
}
public void Initialize()
{
var fixture = new Fixture();
mockShoppingCartRepository = fixture.Build <ShoppingCartRepository>()
.With(x => x.InMemoryShoppingCart, new ShoppingCart()).Create();
sut = new ShoppingCartController(mockShoppingCartRepository);
}
protected void DisplayCurrentCartQty()
{
string username = User.Identity.Name.ToString();
ShoppingCartController sysmgr = new ShoppingCartController();
string currentCount = sysmgr.ShowQtyCartAmount(username);
CurretyItemsQtyCart.Text = currentCount;
}
public void ShoppingCartController_AddItem_ShouldRedirect_ToItemAdded_AndPassIn_ID_1() {
ShoppingCartController controller = new ShoppingCartController(cartService, catalogService);
ActionRedirectResult result = (ActionRedirectResult)controller.AddItem(1);
//we should get a redirect here
Assert.AreEqual("ItemAdded", result.Values["action"].ToString());
Assert.AreEqual("1", result.Values["productID"].ToString());
}
