public void EditDetailsEditsModelIfIdDoesExist()
        {
            // Arrange
            var mediaList     = this.GetMedia();
            var mediaRepoMock = new Mock <IRepository <Media> >();

            mediaRepoMock.Setup(x => x.All())
            .Returns(mediaList.AsQueryable);
            mediaRepoMock.Setup(x => x.AllAsNoTracking())
            .Returns(mediaList.AsQueryable);

            var title         = "Borat";
            var expectedTitle = title + "Film";
            var expectedGenre = "Adventure";
            var editMediaId   = mediaList.FirstOrDefault(x => x.Title == title).Id;
            var expectedCount = mediaList.Count;

            var mediaService = new MediaService(mediaRepoMock.Object, this.genreRepo, this.keywordRepo, this.mediaKeywordRepo);

            var inputModel = new MediaDetailsInputModel()
            {
                Id          = editMediaId,
                Title       = expectedTitle,
                Overview    = "dadadafewfwfewfwefwefwefewfwefwefwefewfwefwefweffew",
                ReleaseDate = DateTime.Now,
                Runtime     = 100,
                Budget      = 100,
                MediaType   = "Movie",
                Genres      = expectedGenre,
            };

            // Act
            Task.Run(async() =>
            {
                await mediaService.EditDetailsAsync(inputModel, string.Empty, string.Empty);
            }).GetAwaiter().GetResult();

            // Assert
            Assert.Equal(expectedCount, mediaRepoMock.Object.All().Count());
            Assert.Equal(expectedTitle, mediaRepoMock.Object.All().FirstOrDefault(x => x.Id == editMediaId).Title);
            Assert.Equal(expectedGenre, mediaRepoMock.Object.All().FirstOrDefault(x => x.Id == editMediaId).Genres.FirstOrDefault().Genre.Name);
        }
        public void EditDetailsAddsModelIfIdDoesNotExists()
        {
            // Arrange
            var mediaList     = this.GetMedia();
            var expectedCount = mediaList.Count + 1;
            var mediaRepoMock = new Mock <IRepository <Media> >();

            mediaRepoMock.Setup(x => x.All())
            .Returns(mediaList.AsQueryable());
            mediaRepoMock.Setup(x => x.AddAsync(It.IsAny <Media>()))
            .Callback((Media model) => mediaList.Add(model));


            var mediaService = new MediaService(mediaRepoMock.Object, this.genreRepo, this.keywordRepo, this.mediaKeywordRepo);

            var inputModel = new MediaDetailsInputModel()
            {
                Title       = "Film",
                Overview    = "dadadafewfwfewfwefwefwefewfwefwefwefewfwefwefweffew",
                ReleaseDate = DateTime.Now,
                Runtime     = 100,
                Budget      = 100,
                MediaType   = "Movie",
                Genres      = "Action, Adventure",
            };

            // Act
            Task.Run(async() =>
            {
                await mediaService.EditDetailsAsync(inputModel, string.Empty, string.Empty);
            }).GetAwaiter().GetResult();

            // Assert
            Assert.Equal(expectedCount, mediaRepoMock.Object.All().Count());
            Assert.True(mediaRepoMock.Object.All().Any(x => x.Title == inputModel.Title));
        }
        public void EditDetailsReplacesKeywordListFromInputModel()
        {
            // Arrange
            var mediaList = this.GetMedia();

            var media             = mediaList[0];
            var keywords          = this.GetKeywords();
            var mediaKeywordsList = new List <MediaKeyword>();

            foreach (var keyword in keywords)
            {
                mediaKeywordsList.Add(new MediaKeyword()
                {
                    Media = media, Keyword = keyword, KeywordId = keyword.Id
                });
            }

            media.Keywords = mediaKeywordsList;

            var mediaMock         = new Mock <IRepository <Media> >();
            var keywordsMock      = new Mock <IRepository <Keyword> >();
            var mediaKeywordsMock = new Mock <IRepository <MediaKeyword> >();

            mediaMock.Setup(x => x.All()).Returns(mediaList.AsQueryable);
            mediaMock.Setup(x => x.AddAsync(It.IsAny <Media>()))
            .Callback((Media model) => mediaList.Add(model));
            keywordsMock.Setup(x => x.AddAsync(It.IsAny <Keyword>()))
            .Callback((Keyword model) => keywords.Add(model));
            mediaKeywordsMock.Setup(x => x.Delete(It.IsAny <MediaKeyword>()))
            .Callback((MediaKeyword model) => mediaKeywordsList.Remove(model));


            var title         = "Borat";
            var expectedTitle = title + "Film";
            var editMediaId   = mediaList.FirstOrDefault(x => x.Title == title).Id;
            var expectedCount = mediaList.Count;
            var expectedGenre = "Adventure";

            var mediaService = new MediaService(mediaMock.Object, this.genreRepo, keywordsMock.Object, mediaKeywordsMock.Object);

            var keywordInput = this.GetKeywords().Select(x => new KeywordViewModel()
            {
                Value = x.Name, Id = x.Id
            }).ToList();

            var newKeyword = new KeywordViewModel()
            {
                Value = "new keyword"
            };

            keywordInput.Add(newKeyword);
            var expectedToBeRemoved = mediaKeywordsList[0];

            keywordInput.RemoveAt(0);

            var serializedKeywords = JsonConvert.SerializeObject(keywordInput);

            var inputModel = new MediaDetailsInputModel()
            {
                Id          = editMediaId,
                Title       = expectedTitle,
                Budget      = 1000,
                Overview    = "ijweifgjwiegjweigoweg",
                Runtime     = 100,
                ReleaseDate = DateTime.Now,
                MediaType   = "Movie",
                Keywords    = serializedKeywords,
                Genres      = expectedGenre,
            };

            // Act
            Task.Run(async() =>
            {
                await mediaService.EditDetailsAsync(inputModel, string.Empty, string.Empty);
            }).GetAwaiter().GetResult();

            // Assert
            Assert.False(media.Keywords.Contains(expectedToBeRemoved));
            Assert.Contains(media.Keywords, x => x.Keyword.Name == newKeyword.Value);
        }