Пример #1
0
        public async Task UpdateCocktail_Updates_Correct()
        {
            //Arrange
            var options = Utils.GetOptions(nameof(UpdateCocktail_Updates_Correct));

            var cocktail = new Cocktail {
                Id = Guid.NewGuid(), Name = "Cuba Libre"
            };
            var cocktailDTO = new CocktailDTO {
                Name = "Cuba Libre Indeed", AlcoholPercentage = 2.5, IsAlcoholic = true
            };

            using (var arrangeContext = new CMContext(options))
            {
                await arrangeContext.Cocktails.AddAsync(cocktail);

                await arrangeContext.SaveChangesAsync();
            }

            //Act, Assert
            using (var assertContex = new CMContext(options))
            {
                var sut    = new CocktailServices(assertContex);
                var result = await sut.UpdateCocktail(cocktail.Id, cocktailDTO);

                Assert.AreEqual("Cuba Libre Indeed", result.Name);
                Assert.AreEqual(2.5, result.AlcoholPercentage);
                Assert.AreEqual(true, result.IsAlcoholic);
                Assert.IsInstanceOfType(result, typeof(CocktailDTO));
            }
        }
        public async Task CreateCocktail_Throws_When_NameExists()
        {
            //Arrange
            var options = Utils.GetOptions(nameof(CreateCocktail_Throws_When_NameExists));

            var cocktail = new Cocktail
            {
                Id   = Guid.NewGuid(),
                Name = "Cuba Libre"
            };

            var cocktailDTO = new CocktailDTO
            {
                Name = "Cuba Libre"
            };

            using (var arrangeContext = new CMContext(options))
            {
                await arrangeContext.Cocktails.AddAsync(cocktail);

                await arrangeContext.SaveChangesAsync();
            }

            //Act, Assert
            using (var assertContext = new CMContext(options))
            {
                var sut = new CocktailServices(assertContext);

                await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.CreateCocktail(cocktailDTO));
            }
        }
        public async Task <CocktailDTO> Create(CocktailDTO cocktailDTO)
        {
            if (this.context.Bars.Any(b => b.Name == cocktailDTO.Name))
            {
                throw new ArgumentException("The name is already existing");
            }

            if (cocktailDTO.Name == null)
            {
                throw new ArgumentNullException("The name is mandatory");
            }

            var cocktail = new Cocktail
            {
                Id = cocktailDTO.Id,
                AlcoholPercentage = cocktailDTO.AlcoholPercentage,
                Bars        = cocktailDTO.Bars,
                Comments    = cocktailDTO.Comments,
                ImageURL    = cocktailDTO.ImageURL,
                Ingredients = cocktailDTO.Ingredients,
                IsAlcoholic = cocktailDTO.IsAlcoholic,
                Name        = cocktailDTO.Name,
                Rating      = cocktailDTO.Rating,
                Stars       = cocktailDTO.Stars
            };

            await context.Cocktails.AddAsync(cocktail);

            await context.SaveChangesAsync();


            return(cocktail.Map());
        }
Пример #4
0
        public async Task GetAllCocktailsDTOReturnsCorrectDTOs()
        {
            var options = TestUtilities.GetOptions(nameof(GetAllCocktailsDTOReturnsCorrectDTOs));

            var ingredientServiceMock   = new Mock <ICocktailIngredientService>();
            var cocktailMapperToDTOMock = new Mock <IDTOServiceMapper <CocktailDTO, Cocktail> >();
            var cocktailMapperMock      = new Mock <IDTOServiceMapper <Cocktail, CocktailDTO> >();
            var commentMapperToDTOMock  = new Mock <IDTOServiceMapper <CommentDTO, CocktailComment> >();
            var commentMapperMock       = new Mock <IDTOServiceMapper <CocktailComment, CommentDTO> >();
            var addCocktailMapperMock   = new Mock <IDTOServiceMapper <Cocktail, AddCocktailDTO> >();
            var cocktailRatingToDTOMock = new Mock <IDTOServiceMapper <RatingDTO, CocktailRating> >();

            var ingrMapper = new Mock <IDTOServiceMapper <CocktailIngredient, CocktailIngredientDTO> >();

            ingrMapper.Setup(x => x.MapFrom(It.IsAny <CocktailIngredient>())).Returns(It.IsAny <CocktailIngredientDTO>());
            var cocktail = new Cocktail()
            {
                Name   = "Name",
                Id     = "1",
                Motto  = "Motto",
                PicUrl = "Pic",
            };
            var cocktail2 = new Cocktail()
            {
                Name   = "Name2",
                Id     = "12",
                Motto  = "Motto2",
                PicUrl = "Pic2",
            };

            var cocktailDTO = new CocktailDTO()
            {
                Name   = "Name",
                Id     = "1",
                Motto  = "Motto",
                PicUrl = "Pic",
            };

            //Act
            cocktailMapperMock.Setup(m => m.MapFrom(It.IsAny <Cocktail>())).Returns(cocktailDTO);

            using (var actContext = new IriOnCocktailServiceDbContext(options))
            {
                await actContext.Cocktails.AddAsync(cocktail);

                await actContext.Cocktails.AddAsync(cocktail2);

                await actContext.SaveChangesAsync();
            }

            using (var assertContext = new IriOnCocktailServiceDbContext(options))
            {
                var sut = new CocktailService(assertContext, ingredientServiceMock.Object, cocktailMapperMock.Object, cocktailMapperToDTOMock.Object, commentMapperToDTOMock.Object, commentMapperMock.Object, addCocktailMapperMock.Object, cocktailRatingToDTOMock.Object);


                var result = await sut.GetAllCocktailsDTO();

                Assert.AreEqual(2, result.Count);
            }
        }
        public CocktailViewModel MapToVMFromDTO(CocktailDTO cocktailDTO)
        {
            if (cocktailDTO == null)
            {
                return(null);
            }
            var cocktailVM = new CocktailViewModel
            {
                Id            = cocktailDTO.Id,
                Name          = cocktailDTO.Name,
                AverageRating = cocktailDTO.AverageRating,
                Bars          = cocktailDTO.Bars.Select(b => new BarViewModel
                {
                    Id   = b.Id,
                    Name = b.Name,
                    //Address = b.Address,
                    CityName = b.CityName,
                    //Phone = b.Phone,
                    AverageRating = b.AverageRating
                }).ToList(),
                Ingredients = cocktailDTO.Ingredients.Select(i => new IngredientViewModel
                {
                    Id   = i.Id,
                    Name = i.Name
                }).ToList(),
                ImageData   = cocktailDTO.ImageData,
                ImageSource = cocktailDTO.ImageSource
            };

            return(cocktailVM);
        }
        public CocktailDTO MapToDTOFromVM(EditCocktailViewModel editCocktailVM)
        {
            if (editCocktailVM == null)
            {
                return(null);
            }
            var cocktailDTO = new CocktailDTO
            {
                Id          = editCocktailVM.Id,
                Name        = editCocktailVM.Name,
                Ingredients = editCocktailVM.ContainedIngredients.Select(i => new IngredientDTO
                {
                    Id = i
                }).ToList(),
                Bars = editCocktailVM.ContainedBars.Select(b => new BarDTO
                {
                    Id = b
                }).ToList(),
            };

            if (editCocktailVM.File != null)
            {
                cocktailDTO.ImageData = editCocktailVM.ImageData;
            }

            return(cocktailDTO);
        }
Пример #7
0
        public async Task CreateCocktail()
        {
            var options        = TestUtilities.GetOptions(nameof(CreateCocktail));
            var mockIngredient = new Mock <IIngredientManager>();
            var mockFactory    = new Mock <ICocktailFactory>();
            var igredients     = new List <string> {
                "first"
            };
            var ingredient = new Ingredient()
            {
                Name = "first",
            };

            var cocktailDTO = new CocktailDTO()
            {
                Name        = "cocktailName",
                Information = "cocktail infromation",
                Picture     = "picture",
            };


            using (var arrangeContext = new CMContext(options))
            {
                await arrangeContext.Ingredients.AddAsync(ingredient);

                await arrangeContext.SaveChangesAsync();

                var sut = new CocktailManager(mockIngredient.Object, arrangeContext, mockFactory.Object);
                await sut.CreateCocktail(cocktailDTO, igredients);
            }
            using (var assertContext = new CMContext(options))
            {
                Assert.AreEqual(1, assertContext.Cocktails.Count());
            }
        }
        public void CorrectMapping_ToEntityModel()
        {
            //Arrange
            var options = Utils.GetOptions(nameof(CorrectMapping_ToEntityModel));

            //Act & Assert
            using (var assertContext = new CocktailMagicianContext(options))
            {
                var cocktailDTO = new CocktailDTO
                {
                    Id            = 5,
                    Name          = "Cuba Libre",
                    AverageRating = 3.5,
                    IsDeleted     = false
                };

                var sut    = new CocktailMapper();
                var result = sut.MapToCocktail(cocktailDTO);

                Assert.IsInstanceOfType(result, typeof(Cocktail));
                Assert.AreEqual(cocktailDTO.Id, result.Id);
                Assert.AreEqual(cocktailDTO.Name, result.Name);
                Assert.AreEqual(cocktailDTO.AverageRating, result.AverageRating);
                Assert.AreEqual(cocktailDTO.IsDeleted, result.IsDeleted);
            }
        }
Пример #9
0
        public CocktailDTO MapToCocktailDTO(Cocktail cocktail)
        {
            if (cocktail == null)
            {
                return(null);
            }
            var cocktailDTO = new CocktailDTO
            {
                Id            = cocktail.Id,
                Name          = cocktail.Name,
                AverageRating = cocktail.AverageRating,
                Bars          = cocktail.CocktailBars.Select(b => new BarDTO
                {
                    Id   = b.Bar.Id,
                    Name = b.Bar.Name
                }).ToList(),
                Ingredients = cocktail.IngredientsCocktails.Select(i => new IngredientDTO
                {
                    Id   = i.Ingredient.Id,
                    Name = i.Ingredient.Name
                }).ToList(),
                IsDeleted   = cocktail.IsDeleted,
                ImageData   = cocktail.ImageData,
                ImageSource = cocktail.ImageSource
            };

            return(cocktailDTO);
        }
Пример #10
0
        /// <summary>
        /// This method adds the new Cocktail to the DataBase after checking if it does not exists already
        /// </summary>
        /// <param name="cocktail">This is the newly created Cocktail object</param>
        /// <returns>Task</returns>
        public async Task CreateCocktail(CocktailDTO cocktail, List <string> ingredients)
        {
            var cocktailToFind = _context.Cocktails.SingleOrDefault(c => c.Name == cocktail.Name);

            if (cocktailToFind != null)
            {
                throw new InvalidOperationException("Cocktail already exists in the database");
            }

            var cocktailToAdd = _cocktailFactory.CreateNewCocktail(cocktail.Name, cocktail.Picture);

            cocktailToAdd.CocktailIngredient = new List <CocktailIngredient>();
            foreach (var ingredient in ingredients)
            {
                var findIngredient = await _ingredientManager.FindIngredientByNameAsync(ingredient);

                if (findIngredient != null)
                {
                    cocktailToAdd.CocktailIngredient.Add(new CocktailIngredient()
                    {
                        Cocktail = cocktailToAdd, Ingredient = findIngredient.ToEntity()
                    });
                }
            }
            cocktailToAdd.Information = CreateCocktailsRecipe(ingredients);
            await _context.Cocktails.AddAsync(cocktailToAdd);

            await _context.SaveChangesAsync();
        }
Пример #11
0
        public async Task RecoverCocktail_When_ItIsDeleted()
        {
            var testCocktailName = "TestCocktailName";
            var options          = Utils.GetOptions(nameof(RecoverCocktail_When_ItIsDeleted));

            var entityCocktail = new Cocktail()
            {
                Name      = testCocktailName,
                IsDeleted = true,
            };

            var dto = new CocktailDTO()
            {
                Name = testCocktailName,
            };

            var mockMapper = new Mock <ICocktailMapper>();

            mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <CocktailDTO>()))
            .Returns((CocktailDTO x) => new Cocktail()
            {
                Name = x.Name,
            });
            mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <Cocktail>()))
            .Returns((Cocktail x) => new CocktailDTO()
            {
                Name = x.Name,
            });

            var mockBarMapper = new Mock <IBarMapper>();


            using (var arrangeContext = new BCcontext(options))
            {
                await arrangeContext.Cocktails
                .AddAsync(entityCocktail);

                await arrangeContext.SaveChangesAsync();
            }

            using (var actContext = new BCcontext(options))
            {
                var sut      = new CocktailsService(actContext, mockMapper.Object, mockBarMapper.Object);
                var cocktail = sut.CreateAsync(dto);
                await actContext.SaveChangesAsync();
            }

            using (var assertContext = new BCcontext(options))
            {
                var sut      = new CocktailsService(assertContext, mockMapper.Object, mockBarMapper.Object);
                var cocktail = await sut.CreateAsync(dto);

                Assert.AreEqual(1, assertContext.Cocktails.Count());

                Assert.IsNotNull(cocktail);
                Assert.AreEqual(testCocktailName, testCocktailName);
                Assert.IsFalse(cocktail.IsDeleted);
            }
        }
 public bool CocktailIsUnique(CocktailDTO cocktailDTO)
 {
     if (this.context.Cocktails.Any(x => x.Name.ToLower().Equals(cocktailDTO.Name.ToLower())))
     {
         return(false);
     }
     return(true);
 }
        public async Task AddCocktailToBar_Throws_When_Cocktail_IsAreadyListed()
        {
            //Arrange
            var options = Utils.GetOptions(nameof(AddCocktailToBar_Throws_When_Cocktail_IsAreadyListed));


            var bar = new Bar
            {
                Id      = Guid.NewGuid(),
                Name    = "Cosmos",
                Country = new Country
                {
                    Id   = Guid.NewGuid(),
                    Name = "Bulgaria"
                }
            };

            var cocktail = new Cocktail
            {
                Id   = Guid.NewGuid(),
                Name = "Manhattan",
            };

            var cocktailDTO = new CocktailDTO
            {
                Id   = cocktail.Id,
                Name = cocktail.Name,
            };

            var barCocktail = new BarCocktail
            {
                BarId      = bar.Id,
                CocktailId = cocktail.Id,
            };

            using (var arrangeContext = new CMContext(options))
            {
                await arrangeContext.Bars.AddAsync(bar);

                await arrangeContext.Cocktails.AddAsync(cocktail);

                await arrangeContext.BarCocktails.AddAsync(barCocktail);

                await arrangeContext.SaveChangesAsync();
            }


            //Act,Assert
            using (var assertContext = new CMContext(options))
            {
                var sut = new BarServices(assertContext);

                await Assert.ThrowsExceptionAsync <InvalidOperationException>(() => sut.AddCocktailToBar(bar.Id, cocktailDTO.Id));
            }
        }
 public CocktailViewModel MapDTOToView(CocktailDTO dto)
 {
     try
     {
         return(new CocktailViewModel
         {
             Id = dto.Id,
             Name = dto.Name,
             Rating = dto.Rating,
             TimesRated = dto.TimesRated,
             ImageSrc = dto.ImageSrc,
             IsDeleted = dto.IsDeleted,
             IsAlcoholic = dto.IsAlcoholic,
             Instructions = dto.Instructions,
             Ingredients = dto.Ingredients.Select(i => new CocktailIngredientViewModel()
             {
                 IngredientId = i.IngredientId,
                 IngredientName = i.IngredientName,
                 Parts = i.Parts
             }).ToList(),
             //Comments = dto.Comments,
             //TODO: Mapping lists ?
             Bars = dto.Bars.Select(b => new CocktailBarView
             {
                 BarId = b.BarId,
                 BarName = b.BarName,
                 CocktailId = b.CocktailId,
                 CocktailName = b.CocktailName,
             }).ToList(),
             Comments = dto.Comments.Select(c => new CocktailUserCommentVM
             {
                 CocktailId = c.CocktailId,
                 CocktailName = c.CocktailName,
                 UserId = c.UserId,
                 UserName = c.UserName,
                 Text = c.Text,
                 IsFlagged = c.IsFlagged,
             }).ToList(),
             CocktailRatings = dto.CocktailRatings.Select(r => new UserCocktailRatingDTO
             {
                 CocktailId = r.CocktailId,
                 CocktailName = r.CocktailName,
                 UserId = r.UserId,
                 UserName = r.UserName,
                 Rating = r.Rating,
             }).ToList(),
             //Instructions = dto.Instructions,
         });
     }
     catch (Exception)
     {
         return(new CocktailViewModel());
     }
 }
        public async Task RemoveCocktailFromBar_Throws_When_Cocktail_NotFound_AtThisBar()
        {
            //Arrange
            var options = Utils.GetOptions(nameof(RemoveCocktailFromBar_Throws_When_Cocktail_NotFound_AtThisBar));


            var bar = new Bar
            {
                Id      = Guid.Parse("86cb5331-0035-4a52-b99b-08df779358e3"),
                Name    = "Cosmos",
                Country = new Country
                {
                    Id   = Guid.Parse("fb837576-a066-43a1-9812-3c1eac4d449c"),
                    Name = "Bulgaria"
                }
            };

            var cocktail = new Cocktail
            {
                Id   = Guid.Parse("bb4b4175-81c5-4828-bca4-3660f796eb3f"),
                Name = "Manhattan",
            };

            var cocktailDTO = new CocktailDTO
            {
                Id   = cocktail.Id,
                Name = cocktail.Name,
            };

            var barCocktail = new BarCocktail
            {
                Id         = Guid.Parse("ca28a84e-1885-4d1b-aee9-3ab4f9ade0f7"),
                CocktailId = cocktail.Id
            };

            using (var arrangeContext = new CMContext(options))
            {
                await arrangeContext.Bars.AddAsync(bar);

                await arrangeContext.Cocktails.AddAsync(cocktail);

                await arrangeContext.BarCocktails.AddAsync(barCocktail);

                await arrangeContext.SaveChangesAsync();
            }

            //Act,Assert
            using (var assertContext = new CMContext(options))
            {
                var sut = new BarServices(assertContext);

                await Assert.ThrowsExceptionAsync <InvalidOperationException>(() => sut.RemoveCocktailFromBar(bar.Id, cocktailDTO.Id));
            }
        }
Пример #16
0
        public async Task GetAllCocktailDTOs_ThrowsCorrectMsgWhenNotAvailable()
        {
            var options = TestUtilities.GetOptions(nameof(GetAllCocktailDTOs_ThrowsCorrectMsgWhenNotAvailable));

            var ingredientServiceMock   = new Mock <ICocktailIngredientService>();
            var cocktailMapperToDTOMock = new Mock <IDTOServiceMapper <CocktailDTO, Cocktail> >();
            var cocktailMapperMock      = new Mock <IDTOServiceMapper <Cocktail, CocktailDTO> >();
            var commentMapperToDTOMock  = new Mock <IDTOServiceMapper <CommentDTO, CocktailComment> >();
            var commentMapperMock       = new Mock <IDTOServiceMapper <CocktailComment, CommentDTO> >();
            var addCocktailMapperMock   = new Mock <IDTOServiceMapper <Cocktail, AddCocktailDTO> >();
            var cocktailRatingToDTOMock = new Mock <IDTOServiceMapper <RatingDTO, CocktailRating> >();

            var ingrMapper = new Mock <IDTOServiceMapper <CocktailIngredient, CocktailIngredientDTO> >();

            ingrMapper.Setup(x => x.MapFrom(It.IsAny <CocktailIngredient>())).Returns(It.IsAny <CocktailIngredientDTO>());
            var cocktail = new Cocktail()
            {
                Name         = "Name",
                Id           = "1",
                Motto        = "Motto",
                PicUrl       = "Pic",
                NotAvailable = true,
            };

            var cocktailDTO = new CocktailDTO()
            {
                Name         = "Name",
                Id           = "1",
                Motto        = "Motto",
                PicUrl       = "Pic",
                NotAvailable = true,
            };

            var cocktailDTOMock = new Mock <CocktailDTO>();
            var cocktailMock    = new Mock <Cocktail>();

            //Act
            cocktailMapperMock.Setup(m => m.MapFrom(It.IsAny <Cocktail>())).Returns(cocktailDTO);

            using (var actContext = new IriOnCocktailServiceDbContext(options))
            {
                await actContext.Cocktails.AddAsync(cocktail);

                await actContext.SaveChangesAsync();
            }

            using (var assertContext = new IriOnCocktailServiceDbContext(options))
            {
                var sut = new CocktailService(assertContext, ingredientServiceMock.Object, cocktailMapperMock.Object, cocktailMapperToDTOMock.Object, commentMapperToDTOMock.Object, commentMapperMock.Object, addCocktailMapperMock.Object, cocktailRatingToDTOMock.Object);

                await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.GetAllCocktailsDTO(), GlobalConstants.NoCocktailsFound);
            }
        }
Пример #17
0
        /// <summary>
        /// This method finds the corresponding Cocktail to update and updates its properties with the new values.
        /// Updates the Cocktails recipe by calling the method UpdateInformation.
        /// </summary>
        /// <param name="cocktail">Object of type Cocktail with new values to update</param>
        /// <param name="ingredientsToRemove">List of ingredients names to remove from Recipe</param>
        /// <param name="ingredientsToAdd">List of ingredients names to add to the recipe</param>
        /// <returns>Task</returns>
        public async Task EditCocktailAsync(CocktailDTO cocktail, List <string> ingredientsToRemove, List <string> ingredientsToAdd)
        {
            var cocktailToUpdate = await _context.Cocktails.Include(c => c.CocktailIngredient).FirstOrDefaultAsync(c => c.Id == cocktail.Id);

            cocktailToUpdate.Name    = cocktail.Name;
            cocktailToUpdate.Picture = cocktail.Picture;
            if (ingredientsToRemove.Count() > 0 && ingredientsToAdd.Count() > 0)
            {
                foreach (var ingredient in ingredientsToRemove)
                {
                    var ingredientToRemove = await _ingredientManager.FindIngredientByNameAsync(ingredient);

                    _context.CocktailIngredients.Remove(cocktailToUpdate.CocktailIngredient.FirstOrDefault(ci => ci.CocktailId == cocktailToUpdate.Id && ci.IngredientId == ingredientToRemove.Id));
                }
                foreach (var ingredient in ingredientsToAdd)
                {
                    var ingredientToAdd = await _ingredientManager.FindIngredientByNameAsync(ingredient);

                    cocktailToUpdate.CocktailIngredient.Add(new CocktailIngredient()
                    {
                        Cocktail   = cocktailToUpdate,
                        Ingredient = ingredientToAdd.ToEntity()
                    });
                }
            }
            else if (ingredientsToRemove.Count() > 0 && ingredientsToAdd.Count() == 0)
            {
                foreach (var ingredient in ingredientsToRemove)
                {
                    var ingredientToRemove = await _ingredientManager.FindIngredientByNameAsync(ingredient);

                    _context.CocktailIngredients.Remove(cocktailToUpdate.CocktailIngredient.FirstOrDefault(ci => ci.CocktailId == cocktailToUpdate.Id && ci.IngredientId == ingredientToRemove.Id));
                }
            }
            else if (ingredientsToRemove.Count() == 0 && ingredientsToAdd.Count() > 0)
            {
                foreach (var ingredient in ingredientsToAdd)
                {
                    var ingredientToAdd = await _ingredientManager.FindIngredientByNameAsync(ingredient);

                    cocktailToUpdate.CocktailIngredient.Add(new CocktailIngredient()
                    {
                        Cocktail   = cocktailToUpdate,
                        Ingredient = ingredientToAdd.ToEntity()
                    });
                }
            }

            _context.Cocktails.Update(cocktailToUpdate);
            await _context.SaveChangesAsync();

            await UpdateInformation(cocktailToUpdate.Id);
        }
        public async Task UpdateCocktail_WhenParamsAreValid()
        {
            //Arrange
            var mockDateTimeprovider = new Mock <IDateTimeProvider>();
            var mockCocktailMapper   = new Mock <ICocktailMapper>();

            mockCocktailMapper.Setup(c => c.MapToCocktail(It.IsAny <CocktailDTO>()))
            .Returns <CocktailDTO>(c => new Cocktail {
                Id = c.Id, Name = c.Name, IsDeleted = c.IsDeleted
            });
            var mockIngMapper = new Mock <IIngredientMapper>();

            mockIngMapper.Setup(i => i.MapToIngredient(It.IsAny <IngredientDTO>()))
            .Returns <IngredientDTO>(i => new Ingredient {
                Id = i.Id, Name = i.Name
            });
            var mockBarMapper             = new Mock <IBarMapper>();
            var mockCocktailReviewService = new Mock <ICocktailReviewService>();
            var options = Utils.GetOptions(nameof(UpdateCocktail_WhenParamsAreValid));

            Utils.GetInMemoryDataBase(options);

            var newDTO = new CocktailDTO
            {
                Name        = "Gin sTonik",
                Ingredients = new List <IngredientDTO>
                {
                    new IngredientDTO
                    {
                        Id = 3
                    },
                    new IngredientDTO
                    {
                        Id = 4
                    }
                }
            };

            //Act & Assert

            using (var assertContext = new CocktailMagicianContext(options))
            {
                var sut = new CocktailService(mockDateTimeprovider.Object, mockCocktailMapper.Object,
                                              mockIngMapper.Object, mockBarMapper.Object, assertContext, mockCocktailReviewService.Object);
                var result = await sut.UpdateCocktailAsync(2, newDTO);

                Assert.AreEqual(newDTO.Id, result.Id);
                Assert.AreEqual(newDTO.Name, result.Name);
                Assert.AreEqual(newDTO.IsDeleted, result.IsDeleted);
                Assert.AreEqual(newDTO.Ingredients.ToList().Count, result.Ingredients.ToList().Count);
                CollectionAssert.AreEqual(newDTO.Ingredients.ToList(), result.Ingredients.ToList());
            }
        }
Пример #19
0
        public static Cocktail ToCreateEntity(this CocktailDTO cocktailDTO)
        {
            var cocktail = new Cocktail
            {
                Name            = cocktailDTO.Name,
                Picture         = cocktailDTO.Picture,
                IsDeleted       = cocktailDTO.IsDeleted,
                CocktailReviews = cocktailDTO.CocktailReviewDTOs?.ToEntity()
            };

            return(cocktail);
        }
Пример #20
0
        public static Cocktail CocktailDTOMapToModel(this CocktailDTO cocktailDTO)
        {
            var cocktail = new Cocktail();

            cocktail.Id          = cocktailDTO.Id;
            cocktail.Name        = cocktailDTO.Name;
            cocktail.Description = cocktailDTO.Description;
            cocktail.UnlistedOn  = cocktailDTO.UnlistedOn;
            cocktail.AvgRating   = cocktailDTO.AvgRating;

            return(cocktail);
        }
        public static CocktailViewModel ToCatalogVM(this CocktailDTO cocktail)
        {
            var cocktailViewModel = new CocktailViewModel()
            {
                CocktailId  = cocktail.Id,
                Information = cocktail.Information,
                Name        = cocktail.Name,
                Picture     = cocktail.Picture,
                Rating      = cocktail.Rating
            };

            return(cocktailViewModel);
        }
        public async Task <CocktailDTO> EditCocktailAsync(CocktailDTO cocktailDTO)
        {
            var cocktail = await GetCocktail(cocktailDTO.Id);

            cocktail.Name   = cocktailDTO.Name;
            cocktail.PicUrl = cocktailDTO.PicUrl;
            cocktail.Motto  = cocktailDTO.Motto;

            this.context.Cocktails.Update(cocktail);
            await this.context.SaveChangesAsync();

            return(cocktailDTO);
        }
        public async Task <ActionResult <CocktailDTO> > PostCocktail(CocktailDTO cocktailDTO)
        {
            try
            {
                var cocktail = await this._service.CreateAsync(cocktailDTO);

                return(Created("PostCocktail", cocktail));
            }
            catch (Exception)
            {
                return(NoContent());
            }
        }
        public async Task <IActionResult> PutCocktail(Guid id, CocktailDTO cocktailDTO)
        {
            try
            {
                var cocktail = await this._service.UpdateAsync(id, cocktailDTO);

                return(RedirectToAction());
            }
            catch (Exception)
            {
                return(NoContent());
            }
        }
        public async Task AddCocktailToBar_Adds_Correctly_When_Params_Are_Valid()
        {
            //Arrange
            var options = Utils.GetOptions(nameof(AddCocktailToBar_Adds_Correctly_When_Params_Are_Valid));


            var bar = new Bar
            {
                Id      = Guid.NewGuid(),
                Name    = "Cosmos",
                Country = new Country
                {
                    Id   = Guid.NewGuid(),
                    Name = "Bulgaria"
                }
            };

            var cocktail = new Cocktail
            {
                Id   = Guid.NewGuid(),
                Name = "Manhattan",
            };

            var cocktailDTO = new CocktailDTO
            {
                Id   = cocktail.Id,
                Name = cocktail.Name,
            };

            using (var arrangeContext = new CMContext(options))
            {
                await arrangeContext.Bars.AddAsync(bar);

                await arrangeContext.Cocktails.AddAsync(cocktail);

                await arrangeContext.SaveChangesAsync();
            }


            //Act,Assert
            using (var assertContext = new CMContext(options))
            {
                var sut    = new BarServices(assertContext);
                var result = await sut.AddCocktailToBar(bar.Id, cocktailDTO.Id);

                Assert.AreEqual(1, assertContext.BarCocktails.Count());
                Assert.AreEqual(1, result.BarCocktails.Count());
                Assert.AreEqual(true, result.BarCocktails.ToList()[0].IsListed);
                Assert.IsInstanceOfType(result, typeof(BarDTO));
            }
        }
Пример #26
0
        public static Cocktail ToEntity(this CocktailDTO cocktailDTO)
        {
            var cocktail = new Cocktail
            {
                Id              = cocktailDTO.Id,
                Name            = cocktailDTO.Name,
                Information     = cocktailDTO.Information,
                Picture         = cocktailDTO.Picture,
                IsDeleted       = cocktailDTO.IsDeleted,
                CocktailReviews = cocktailDTO.CocktailReviewDTOs?.ToEntity()
            };

            return(cocktail);
        }
Пример #27
0
        public static CocktailDTO ToCatalogDTO(this Cocktail cocktail)
        {
            var cocktailDTO = new CocktailDTO
            {
                Id          = cocktail.Id,
                Name        = cocktail.Name,
                Information = cocktail.Information,
                Picture     = cocktail.Picture,
                IsDeleted   = cocktail.IsDeleted,
                Rating      = cocktail.Rating
            };

            return(cocktailDTO);
        }
        public static CocktailDTO ToEditDTO(this CocktailViewModel cocktailView)
        {
            var cocktailDTO = new CocktailDTO()
            {
                Id                     = cocktailView.CocktailId,
                Information            = cocktailView.Information,
                Name                   = cocktailView.Name,
                Picture                = cocktailView.Picture,
                Rating                 = cocktailView.Rating,
                CocktailIngredientDTOs = cocktailView.CocktailIngredients != null?cocktailView.CocktailIngredients.ToDTO() : new List <CocktailIngredientDTO>()
            };

            return(cocktailDTO);
        }
        public static CocktailViewModel ToEditVM(this CocktailDTO cocktail)
        {
            var cocktailViewModel = new CocktailViewModel()
            {
                CocktailId          = cocktail.Id,
                Information         = cocktail.Information,
                Name                = cocktail.Name,
                Picture             = cocktail.Picture,
                Rating              = cocktail.Rating,
                CocktailIngredients = cocktail.CocktailIngredientDTOs.ToVM()
            };

            return(cocktailViewModel);
        }
        public static CocktailDTO ToDTO(this CocktailViewModel cocktailView)
        {
            var cocktailViewModel = new CocktailDTO()
            {
                //Id = cocktailView.CocktailId,
                //Information = cocktailView.Information,
                Name               = cocktailView.Name,
                Picture            = cocktailView.Picture,
                Rating             = cocktailView.Rating,
                CocktailReviewDTOs = cocktailView.ReviewViewModels?.ToCocktailReviewDTO()
            };

            return(cocktailViewModel);
        }