public void GetAllMarkdownsReturnsListOfMarkdowns()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.GetAll()).Returns(markdownList);

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);
            var markdowns = markdownDataAccessor.GetAll();

            Assert.NotNull(markdowns);
        }
        public void GetByProductNameWithExistingMarkdownReturnsMarkdown()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.GetByProductName("Can of soup")).Returns(validMarkdown);

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);
            var markdown = markdownDataAccessor.GetByProductName("Can of soup");

            Assert.NotNull(markdown);
        }
        public void GetMarkdownAmountWithNonExistentMarkdownReturnsZero()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.GetByProductName("Bananas")).Returns((Markdown)null);

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);
            var markdownAmount = markdownDataAccessor.GetAmountByProductName("Bananas");

            Assert.AreEqual(markdownAmount, 0);
        }
        public void GetMarkdownAmountWithExistingMarkdownReturnsRightMarkdownAmount()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.GetByProductName("Can of soup")).Returns(validMarkdown);

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);
            var markdownAmount = markdownDataAccessor.GetAmountByProductName("Can of soup");

            Assert.AreEqual(markdownAmount, validMarkdown.Amount);
        }
        public void AddingMarkdownForNonExistentReturnsErrorMessage()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.Save(markdownForNonExistentPrice));

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);

            var result = markdownDataAccessor.Save(markdownForNonExistentPrice);

            Assert.AreEqual(result, "Error: Cannot add markdown for a product that doesn't have a price.");
        }
        public void AddingInvalidMarkdownReturnsErrorMessage()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.Save(invalidMarkdown));

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);

            var result = markdownDataAccessor.Save(invalidMarkdown);

            Assert.AreEqual(result, "Error: Markdown must be smaller than price.");
        }
        public void AddingValidMarkdownReturnsSuccess()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.Save(validMarkdown));

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);

            var result = markdownDataAccessor.Save(validMarkdown);

            Assert.AreEqual(result, "Success.");
        }
        public void UpdateNonExistentMarkdownReturnsError()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.Update(nonExistentMarkdownWithExistingPrice)).Returns(false);
            mockMarkdownRepository.Setup(x => x.GetAll()).Returns(markdownList);

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);

            var result = markdownDataAccessor.Update(nonExistentMarkdownWithExistingPrice);

            Assert.AreEqual(result, "Markdown does not exist, create markdown before updating price.");
        }
        public void UpdateMarkdownForNonExistentPriceReturnsError()
        {
            Mock <IRepository <Markdown> > mockMarkdownRepository = new Mock <IRepository <Markdown> >();

            mockMarkdownRepository.Setup(x => x.Update(nonExistentMarkdownWithoutExistingPrice)).Returns(false);
            mockMarkdownRepository.Setup(x => x.GetAll()).Returns(markdownList);

            Mock <IRepository <Product> > mockPriceRepository = new Mock <IRepository <Product> >();

            mockPriceRepository.Setup(x => x.GetAll()).Returns(productList);

            MarkdownDataAccessor markdownDataAccessor = new MarkdownDataAccessor(mockMarkdownRepository.Object,
                                                                                 mockPriceRepository.Object);

            var result = markdownDataAccessor.Update(nonExistentMarkdownWithoutExistingPrice);

            Assert.AreEqual(result, "Error: Cannot update markdown for a product that doesn't have a price.");
        }