public async Task UpsertDailyReportAsync_IfDbUpdateFailed_ReturnsEmptyReport()
        {
            //Prepare test
            if (!dishes.Any())
            {
                var dish = new ConsumedDish();
                dishes.Add(dish);
            }

            reportsRepositoryMock.Setup(r => r.GetItemsAsync(It.IsAny <Expression <Func <DailyReport, bool> > >(), null, "User"))
            .ReturnsAsync(new List <DailyReport>());

            reportsRepositoryMock.Setup(r => r.AddItemAsync(It.IsAny <DailyReport>()))
            .ReturnsAsync(-1)
            .Verifiable();

            //Do test
            var result = await reportService.UpsertDailyReportAsync(1, DateTime.Today);

            //Assert
            reportsRepositoryMock.Verify(x => x.AddItemAsync(It.IsAny <DailyReport>()), Times.Once);
            usersRepositoryMock.Verify(x => x.GetItemAsync(1, ""), Times.Never);

            Assert.Equal(DateTime.Today, result.ReportDate);
            Assert.Null(result.CustomerName);
            Assert.Null(result.CustomerSurname);
            Assert.Null(result.Warnings);
            Assert.False(result.HasWarnings);
            Assert.Equal(0, result.FatsAmount);
        }
        public async Task UpsertDailyReportAsync_IfRepotDoesNotExist_CreatesNewReport()
        {
            //Prepare test
            var dish = new ConsumedDish();

            dishes.Add(dish);

            reportsRepositoryMock.Setup(r => r.GetItemsAsync(It.IsAny <Expression <Func <DailyReport, bool> > >(), null, "User"))
            .ReturnsAsync(new List <DailyReport>());

            reportsRepositoryMock.Setup(r => r.AddItemAsync(It.IsAny <DailyReport>()))
            .ReturnsAsync(1)
            .Verifiable();

            //Do test
            var result = await reportService.UpsertDailyReportAsync(1, DateTime.Today);

            //Assert
            calculationsServiceMock.Verify(x => x.CalculateDailyAmount(dishes, It.IsAny <DailyReport>()), Times.Once);
            dietServiceMock.Verify(x => x.ValidateDailyReport(It.IsAny <DailyReport>()), Times.Once);
            reportsRepositoryMock.Verify(x => x.AddItemAsync(It.IsAny <DailyReport>()), Times.Once);
            usersRepositoryMock.Verify(x => x.GetItemAsync(1, ""), Times.Once);

            Assert.False(result.HasWarnings);
            Assert.Equal(100, result.FatsAmount);
            Assert.Equal("", result.Warnings);
            Assert.Equal(DateTime.Today, result.ReportDate);
            Assert.Equal(user.Name, result.CustomerName);
            Assert.Equal(user.Surname, result.CustomerSurname);
        }
Exemple #3
0
        private Food MapConsumedDisOnFood(ConsumedDish dish)
        {
            var dishItem = new Food()
            {
                CarbohydratesAmount = dish.CarbohydratesAmount,
                FatsAmount          = dish.FatsAmount,
                ProteinsAmount      = dish.ProteinsAmount,
                Name        = dish.Name,
                Description = dish.Description
            };

            return(dishItem);
        }
        public async Task UpdateLogItemAsync_WhenItemDoesNotExist_ThrowsError()
        {
            //Prepare test
            ConsumedDish dish    = null;
            var          logItem = new ConsumeLogItem {
                Id = 1
            };

            _dishRepositoryMock.Setup(a => a.GetItemAsync(1, "")).ReturnsAsync(dish);

            //Do Test and assert and Test
            var exception = await Assert.ThrowsAsync <ArgumentException>(async() => await _dishService.UpdateLogItem(logItem));

            Assert.Equal("Consumed dish with id 1 does not exist in database!", exception.Message);
        }
        public async Task AddLogItemAsync_IfFails_ReturnsZero()
        {
            //PrepareTest
            var logItem      = new ConsumeLogItem();
            var consumedDish = new ConsumedDish();

            _dishRepositoryMock.Setup(x => x.AddItemAsync(consumedDish)).ReturnsAsync(-1).Verifiable();
            _mapperMock.Setup(m => m.Map <ConsumedDish>(logItem)).Returns(consumedDish);

            //Do test
            var result = await _dishService.AddLogItemAsync(logItem);

            //Assert
            _dishRepositoryMock.Verify(r => r.AddItemAsync(consumedDish), Times.Once);
            Assert.Equal(-1, result);
        }
        public async Task UpdateLogItemAsync()
        {
            //Prepare test
            ConsumedDish dish    = new ConsumedDish();
            var          logItem = new ConsumeLogItem {
                Id = 1, CustomerId = 1, DateOfConsume = DateTime.Today
            };

            _dishRepositoryMock.Setup(a => a.GetItemAsync(1, "")).ReturnsAsync(dish);
            _dishRepositoryMock.Setup(a => a.UpdateItemAsync(dish)).ReturnsAsync(1);
            _mapperMock.Setup(m => m.Map <ConsumedDish>(logItem)).Returns(dish);
            _dishService.AutoUpdateDailyReport = true;

            //Do test
            var result = await _dishService.UpdateLogItem(logItem);

            //Assert
            _reportServiceMock.Verify(s => s.UpsertDailyReportAsync(1, DateTime.Today), Times.Once);
            Assert.Equal(1, result);
        }
        public async Task AddLogItemAsync()
        {
            //PrepareTest
            var logItem = new ConsumeLogItem()
            {
                CustomerId = 1, DateOfConsume = DateTime.Today
            };
            var consumedDish = new ConsumedDish();

            _dishRepositoryMock.Setup(x => x.AddItemAsync(consumedDish)).ReturnsAsync(1).Verifiable();
            _mapperMock.Setup(m => m.Map <ConsumedDish>(logItem)).Returns(consumedDish);
            _dishService.AutoUpdateDailyReport = true;

            //Do test
            var result = await _dishService.AddLogItemAsync(logItem);

            //Assert
            _reportServiceMock.Verify(s => s.UpsertDailyReportAsync(1, DateTime.Today), Times.Once);
            _dishRepositoryMock.Verify(r => r.AddItemAsync(consumedDish), Times.Once);
            Assert.Equal(1, result);
        }