Exemplo n.º 1
0
        public void CheckRunningTotalForBasketWithItems()
        {
            //Arrange
            var view      = new MockedCheckOutView();
            var presenter = new CheckOutPresenter(view, new MockedCheckOutRepository());

            //Act
            presenter.GetRunningTotal();

            //Assert
            Assert.AreEqual(8.95m, view.RunningTotal);
        }
Exemplo n.º 2
0
        public void CheckListContainsItems()
        {
            //Arrange
            var view      = new MockedCheckOutView();
            var presenter = new CheckOutPresenter(view, new MockedCheckOutRepository());

            //Act
            presenter.GetItemsOrderedByPrice();

            //Assert
            Assert.IsTrue(view.CheckoutItems.Count > 0);
        }
Exemplo n.º 3
0
        public void CheckListIsOrderedByPrice()
        {
            //Arrange
            var view      = new MockedCheckOutView();
            var presenter = new CheckOutPresenter(view, new MockedCheckOutRepository());

            //Act
            presenter.GetItemsOrderedByPrice();

            //Assert
            Assert.IsTrue(view.CheckoutItems.Count > 0);
            Assert.AreEqual(0.50m, view.CheckoutItems[0].Price);
            Assert.AreEqual(1.50m, view.CheckoutItems[1].Price);
            Assert.AreEqual(2.75m, view.CheckoutItems[2].Price);
            Assert.AreEqual(4.20m, view.CheckoutItems[3].Price);
        }
Exemplo n.º 4
0
        protected void Page_Load(object sender, EventArgs e)
        {
            // Create the presenter and pass in the view (this) and our repository. (Fake DB layer)
            var presenter = new CheckOutPresenter(this, new CheckoutRepository());

            // Use Presenter to get the Ordered list.
            // This binds the results to the view property 'CheckoutItems'
            presenter.GetItemsOrderedByPrice();

            CheckoutList.DataSource    = CheckoutItems;
            CheckoutList.DataTextField = "Description";
            CheckoutList.DataBind();

            // Use Presenter to get the running total.
            // This binds the results to the view property 'RunningTotal'
            presenter.GetRunningTotal();

            CheckoutTotal.Text = RunningTotal.ToString();
        }
Exemplo n.º 5
0
        public void ShouldCallClearMethodFromShoppingCartsService()
        {
            // Arrange
            var cartId       = "4212345";
            var shoppingCart = new ShoppingCart();

            var mockedView = new Mock <ICheckOutView>();

            mockedView.Setup(v => v.Model).Returns(new CheckOutViewModel());
            var mockedShoppingCartsService = new Mock <IShoppingCartsService>();

            mockedShoppingCartsService.Setup(scs =>
                                             scs.GetCart(It.IsAny <string>()))
            .Returns(shoppingCart)
            .Verifiable();

            mockedShoppingCartsService.Setup(scs => scs.Clear(It.IsAny <ShoppingCart>())).Verifiable();

            var mockedUsersService     = new Mock <IUsersService>();
            var mockedOrdersService    = new Mock <IOrdersService>();
            var mockedAddressesService = new Mock <IAddressesService>();
            var mockedAddressesFactory = new Mock <IAddressesFactory>();
            var mockedOrdersFactory    = new Mock <IOrdersFactory>();


            var checkOutPresenter = new CheckOutPresenter(mockedView.Object,
                                                          mockedShoppingCartsService.Object,
                                                          mockedUsersService.Object,
                                                          mockedOrdersService.Object,
                                                          mockedAddressesService.Object,
                                                          mockedAddressesFactory.Object,
                                                          mockedOrdersFactory.Object);

            // Act
            mockedView.Raise(v => v.CartClearing += null, new CartClearEventArgs(cartId));

            // Assert
            mockedShoppingCartsService.Verify(scs => scs.Clear(shoppingCart), Times.Once);
        }
Exemplo n.º 6
0
        public void ShouldSubscribeToCheckOutViewOnCartClearingEvent()
        {
            // Arrange
            var mockedView = new MockedCheckOutView();
            var mockedShoppingCartsService = new Mock <IShoppingCartsService>();
            var mockedUsersService         = new Mock <IUsersService>();
            var mockedOrdersService        = new Mock <IOrdersService>();
            var mockedAddressesService     = new Mock <IAddressesService>();
            var mockedAddressesFactory     = new Mock <IAddressesFactory>();
            var mockedOrdersFactory        = new Mock <IOrdersFactory>();

            // Act
            var checkOutPresenter = new CheckOutPresenter(mockedView,
                                                          mockedShoppingCartsService.Object,
                                                          mockedUsersService.Object,
                                                          mockedOrdersService.Object,
                                                          mockedAddressesService.Object,
                                                          mockedAddressesFactory.Object,
                                                          mockedOrdersFactory.Object);

            // Assert
            Assert.IsTrue(mockedView.IsSubscribedMethod("OnCartClearing"));
        }
Exemplo n.º 7
0
        public void ShouldCreateAnInstanceInheritingPresenter_WhenValidDependenciesArePassed()
        {
            // Arrange
            var mockedView = new Mock <ICheckOutView>();
            var mockedShoppingCartsService = new Mock <IShoppingCartsService>();
            var mockedUsersService         = new Mock <IUsersService>();
            var mockedOrdersService        = new Mock <IOrdersService>();
            var mockedAddressesService     = new Mock <IAddressesService>();
            var mockedAddressesFactory     = new Mock <IAddressesFactory>();
            var mockedOrdersFactory        = new Mock <IOrdersFactory>();

            // Act
            var checkOutPresenter = new CheckOutPresenter(mockedView.Object,
                                                          mockedShoppingCartsService.Object,
                                                          mockedUsersService.Object,
                                                          mockedOrdersService.Object,
                                                          mockedAddressesService.Object,
                                                          mockedAddressesFactory.Object,
                                                          mockedOrdersFactory.Object);

            // Assert
            Assert.IsInstanceOf <Presenter <ICheckOutView> >(checkOutPresenter);
        }
Exemplo n.º 8
0
        public void Init()
        {
            // Arrange
            var permanentProducts = new List <CartProduct>()
            {
                new CartProduct()
                {
                    Id = 1, Total = 120
                },
                new CartProduct()
                {
                    Id = 5, Total = 200
                },
            };

            this.shoppingCart = new ShoppingCart()
            {
                Total = 42, PermamentProducts = permanentProducts
            };
            this.address = new Address()
            {
                Id = 2
            };
            this.user  = new User();
            this.order = new Order();

            this.mockedView = new Mock <ICheckOutView>();
            mockedView.Setup(v => v.Model).Returns(new CheckOutViewModel());

            this.mockedShoppingCartsService = new Mock <IShoppingCartsService>();
            mockedShoppingCartsService.Setup(scs => scs.GetCart(It.IsAny <string>()))
            .Returns(shoppingCart)
            .Verifiable();

            this.mockedUsersService = new Mock <IUsersService>();
            mockedUsersService.Setup(us => us.GetUserById(It.IsAny <string>()))
            .Returns(user)
            .Verifiable();

            this.mockedOrdersService = new Mock <IOrdersService>();
            mockedOrdersService.Setup(os => os.AddOrder(It.IsAny <Order>())).Verifiable();

            this.mockedAddressesService = new Mock <IAddressesService>();
            mockedAddressesService.Setup(ads => ads.AddAddress(It.IsAny <Address>())).Verifiable();

            this.mockedAddressesFactory = new Mock <IAddressesFactory>();
            mockedAddressesFactory.Setup(af => af.CreateAddress(It.IsAny <string>(),
                                                                It.IsAny <string>(),
                                                                It.IsAny <string>()))
            .Returns(address)
            .Verifiable();

            this.mockedOrdersFactory = new Mock <IOrdersFactory>();
            mockedOrdersFactory.Setup(of => of.CreateOrder(It.IsAny <string>(),
                                                           It.IsAny <User>(),
                                                           It.IsAny <DateTime>(),
                                                           It.IsAny <decimal>(),
                                                           It.IsAny <int>(),
                                                           It.IsAny <Address>(),
                                                           It.IsAny <string>(),
                                                           It.IsAny <OrderPaymentStatusType>(),
                                                           It.IsAny <OrderStatusType>()))
            .Returns(order)
            .Verifiable();

            var checkOutPresenter = new CheckOutPresenter(this.mockedView.Object,
                                                          this.mockedShoppingCartsService.Object,
                                                          this.mockedUsersService.Object,
                                                          this.mockedOrdersService.Object,
                                                          this.mockedAddressesService.Object,
                                                          this.mockedAddressesFactory.Object,
                                                          this.mockedOrdersFactory.Object);
        }