public void SearchIngridients_ShouldThrow_SearchException(SearchIngridientModel searchIngridientModel, string expectedMessage)
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService = new IngridientService(ingridientRepository.Object);

            //Act
            var exception = Assert.ThrowsAsync <SearchException>(() => ingridientService.SearchIngridients(searchIngridientModel));

            //Assert
            Assert.AreEqual(expectedMessage, exception.Message);
        }
        public void UpdateIngridient_ShouldThrow_EntityException(IngridientUpdateModel ingridient, string expectedMessage)
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService = new IngridientService(ingridientRepository.Object);

            //Act
            var exception = Assert.ThrowsAsync <EntityException>(() => ingridientService.UpdateIngridient(1, ingridient));

            //Assert
            Assert.AreEqual(expectedMessage, exception.Message);
        }
        public async Task GetIngridients_ShouldReturn_EntityDoesntExistException()
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService = new IngridientService(ingridientRepository.Object);
            var idOfIngridient    = 100;

            //Act
            var exception = Assert.ThrowsAsync <EntityDoesNotExistException>(() => ingridientService.GetIngridients(new int[] { idOfIngridient }));

            //Assert
            Assert.AreEqual("One or more ingridients don't exist", exception.Message);
        }
        public async Task DeleteIngridient_ShouldDeleteIngridient()
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService = new IngridientService(ingridientRepository.Object);
            var idOfIngridient    = 1;

            //Act
            await ingridientService.DeleteIngridient(idOfIngridient);

            //Assert
            Assert.IsFalse(dataBase.ContainsKey(idOfIngridient));
        }
        public async Task SearchIngridients_ShouldReturn_Ingridients()
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService     = new IngridientService(ingridientRepository.Object);
            var ingridientSearchModel = new SearchIngridientModel();

            //Act
            var ingridients = await ingridientService.SearchIngridients(ingridientSearchModel);

            //Assert
            Assert.AreEqual(dataBase.Select(p => p.Value).ToList(), ingridients);
        }
        public async Task GetIngridients_ShouldReturnIngridients()
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService = new IngridientService(ingridientRepository.Object);
            var idOfIngridient    = 1;

            //Act
            var ingridient = (await ingridientService.GetIngridients(new int[] { idOfIngridient })).First();

            //Assert
            Assert.AreEqual("Ingridient1", ingridient.Name);
            Assert.AreEqual(200, ingridient.Kcal);
        }
        public void UpdateIngridient_ShouldThrow_EntityDoesntExistException()
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService     = new IngridientService(ingridientRepository.Object);
            var ingridientUpdateModel = new IngridientUpdateModel()
            {
                Name = "Ingridient1", Kcal = 200
            };
            var idOfIngridientToBeUpdated = 100;

            //Act
            var exception = Assert.ThrowsAsync <EntityDoesNotExistException>(() => ingridientService.UpdateIngridient(idOfIngridientToBeUpdated, ingridientUpdateModel));

            //Assert
            Assert.AreEqual("Ingridient with id = 100 doesn't exist", exception.Message);
        }
        public async Task CreateIngridient_ShouldCreateIngridient()
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService         = new IngridientService(ingridientRepository.Object);
            var idOfIngridientToBeCreated = dataBase.Count + 1;
            var ingridient = new Ingridient()
            {
                Name = "UpdatedIngridient1", Kcal = 300
            };

            //Act
            var createdIngridientModel = await ingridientService.CreateIngridient(ingridient);

            //Assert
            Assert.AreEqual(createdIngridientModel.Name, dataBase[idOfIngridientToBeCreated].Name);
            Assert.AreEqual(createdIngridientModel.Kcal, dataBase[idOfIngridientToBeCreated].Kcal);
        }
        public async Task UpdateIngridient_ShouldUpdateModel()
        {
            //Arrange
            var(ingridientRepository, dataBase) = GetMocks();
            var ingridientService         = new IngridientService(ingridientRepository.Object);
            var idOfIngridientToBeUpdated = 1;
            var ingridientUpdateModel     = new IngridientUpdateModel()
            {
                Name = "UpdatedIngridient1", Kcal = 300
            };

            //Act
            var updatedIngridientModel = await ingridientService.UpdateIngridient(idOfIngridientToBeUpdated, ingridientUpdateModel);

            //Assert
            Assert.AreEqual(updatedIngridientModel.Name, dataBase[idOfIngridientToBeUpdated].Name);
            Assert.AreEqual(updatedIngridientModel.Kcal, dataBase[idOfIngridientToBeUpdated].Kcal);
        }