public void AddEntityToBase_WhenEntityIsCorrect() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "AddEntityToBase_WhenEntityIsCorrect") .Options; var testMovie = new Movie { Name = "TestMovie" }; //Act using (var actContext = new AlphaCinemaContext(contextOptions)) { var movieRepo = new Repository <Movie>(actContext); movieRepo.Add(testMovie); movieRepo.Save(); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { Assert.IsTrue(assertContext.Movies.Count() == 1); Assert.IsTrue(assertContext.Movies.Contains(testMovie)); } }
public void AddAllPreviousMovieGenres_WhenMovieIsRestored() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "AddAllPreviousMovieGenres_WhenMovieIsRestored") .Options; movie.IsDeleted = true; movieGenre.IsDeleted = true; movie.MovieGenres.Add(movieGenre); //Act using (var actContext = new AlphaCinemaContext(contextOptions)) { actContext.Movies.Add(movie); actContext.SaveChanges(); var unitOfWork = new UnitOfWork(actContext); var addMovieCommand = new MovieServices(unitOfWork); addMovieCommand.AddNewMovie(testMovieName, testMovieDescription, testMovieReleaseYear, testMovieDuration); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { Assert.IsFalse(movie.MovieGenres.First().IsDeleted); } }
public async Task CorrectlyReturnAllUsers() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "CorrectlyReturnAllUsers") .Options; user = new User() { FirstName = "Krasimir", LastName = "Etov", Age = 21, }; //Act using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var userService = new UserService(serviceProviderMock.Object, assertContext); var users = await userService.GetAllUsers(); Assert.IsTrue(users.Count == 1); } }
public async Task ChangeIsDeletedToFalse_WhenMovieAlreadyExist() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ChangeIsDeletedToFalse_WhenMovieAlreadyExist") .UseInternalServiceProvider(serviceProvider) .Options; using (var arrangeContext = new AlphaCinemaContext(contextOptions)) { movie.IsDeleted = true; await arrangeContext.AddAsync(movie); await arrangeContext.SaveChangesAsync(); } //Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new MovieService(assertContext); await command.AddMovie(movieName, movieDescription, releaseYear, movieDuration); Assert.IsTrue(!assertContext.Movies.First().IsDeleted); Assert.AreEqual(1, await assertContext.Movies.CountAsync()); Assert.AreEqual(movieName, assertContext.Movies.First().Name); Assert.AreEqual(movieDescription, assertContext.Movies.First().Description); Assert.AreEqual(int.Parse(movieDuration), assertContext.Movies.First().Duration); Assert.AreEqual(int.Parse(releaseYear), assertContext.Movies.First().ReleaseYear); } }
public async Task ReturnUserIfUserIdIsFound() { contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ReturnUserIfUserIdIsFound") .Options; // Arrange string userId = "myId"; user = new User() { Id = userId, FirstName = "Krasimir", LastName = "Etov", Age = 21, }; using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.SaveChangesAsync(); } // Act && Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var userService = new UserService(serviceProviderMock.Object, assertContext); var result = await userService.GetUser(userId); Assert.IsNotNull(result); Assert.AreEqual(result.Id, userId); } }
public async Task ChangeIsDeletedToFalse_WhenExistAndParametersAreValid() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ChangeIsDeletedToFalse_WhenExistAndParametersAreValid") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.AddAsync(deletedReservation); await actContext.SaveChangesAsync(); var command = new ProjectionService(actContext); await command.AddReservation(testUserId, testProjectionId); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { Assert.IsTrue(assertContext.WatchedMovies.Count() == 1); Assert.IsTrue(assertContext.WatchedMovies.First().IsDeleted == false); } }
public async Task ReturnMovie_WhenNameIsValid() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ReturnMovie_WhenNameIsValid") .UseInternalServiceProvider(serviceProvider) .Options; var listOfMovies = new List <Movie>() { testMovieOne, testMovieTwo }; //Act using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.AddRangeAsync(listOfMovies); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new MovieService(assertContext); var result = await command.GetMovie(testMovieOneName); Assert.AreEqual(testMovieOneName, result.Name); Assert.AreEqual(movieId, result.Id); } }
public async Task Throw_InvalidClientInputException_When_ParametersAreNotValid() { DbContextOptions <AlphaCinemaContext> contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "Throw_InvalidClientInputException_When_ParametersAreNotValid") .Options; // Arrange var cityName = "Te"; var city = new City() { Name = cityName }; using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.Cities.AddAsync(city); await actContext.SaveChangesAsync(); } // Act && Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var cityServices = new CityService(assertContext); await Assert.ThrowsExceptionAsync <InvalidClientInputException>(() => cityServices.AddCity(cityName)); } }
public async Task AddNewMovie_WhenParametersAreCorrect() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "AddNewMovie_WhenParametersAreCorrect") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new AlphaCinemaContext(contextOptions)) { var command = new MovieService(actContext); await command.AddMovie(movieName, movieDescription, releaseYear, movieDuration); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { Assert.AreEqual(1, await assertContext.Movies.CountAsync()); Assert.AreEqual(movieName, assertContext.Movies.First().Name); Assert.AreEqual(movieDescription, assertContext.Movies.First().Description); Assert.AreEqual(int.Parse(movieDuration), assertContext.Movies.First().Duration); Assert.AreEqual(int.Parse(releaseYear), assertContext.Movies.First().ReleaseYear); } }
public async Task AddNewCity_WhenParametersAreCorrect(string cityName) { var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "AddNewCity_WhenParametersAreCorrect") .Options; var city = new City() { Name = cityName }; using (var context = new AlphaCinemaContext(contextOptions)) { await context.Cities.AddAsync(city); await context.SaveChangesAsync(); var cityService = new CityService(context); city = await cityService.AddCity(cityName); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { Assert.IsInstanceOfType(city, typeof(City)); Assert.IsNotNull(city); } }
public async Task SuccessfullyModifyDateWhenUserIsValid() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "SuccessfullyModifyDateWhenUserIsValid") .Options; string userId = "djoni"; user = new User() { Id = userId, FirstName = "Krasimir", LastName = "Etov", Age = 21 }; using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.SaveChangesAsync(); } // Act && Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var userService = new UserService(serviceProviderMock.Object, assertContext); await userService.Modify(userId); // please don't kill me user = await userService.GetUser(userId); Assert.AreEqual(DateTime.Now.Year, user.ModifiedOn.Value.Year); } }
public async Task ThrowEntityDoesntExistExceptionWhenUserIsDeleted() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowEntityDoesntExistExceptionWhenUserIsDeleted") .Options; user = new User() { Id = "my id", FirstName = "Krasimir", LastName = "Etov", Age = 21, IsDeleted = true }; using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.Users.AddAsync(user); await actContext.SaveChangesAsync(); } //Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var userService = new UserService(serviceProviderMock.Object, assertContext); await Assert.ThrowsExceptionAsync <EntityDoesntExistException>(() => userService.Modify(user.Id)); } }
public async Task ThrowEntityAlreadyExistsExceptionWhenParamsAreValid() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowEntityAlreadyExistsExceptionWhenParamsAreValid") .Options; var userId = "userId"; var projectionId = 5; watchedMovie = new WatchedMovie() { UserId = userId, ProjectionId = projectionId }; using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.WatchedMovies.AddAsync(watchedMovie); await actContext.SaveChangesAsync(); } // Act && Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var watchedMoviesService = new WatchedMoviesService(assertContext); await Assert.ThrowsExceptionAsync <EntityAlreadyExistsException>(() => watchedMoviesService.AddNewWatchedMovie(userId, projectionId)); } }
public async Task AddNewWatchedMovie_WhenDontExistAndParametersAreValid() { // Arrange //Important: InMemory is designed to be a general purpose database for testing, //and is not designed to mimic a relational database. //Simply said InMemory database wont respect the foreign key constraint var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "AddNewWatchedMovie_WhenDontExistAndParametersAreValid") .UseInternalServiceProvider(serviceProvider) .Options; //Act using (var actContext = new AlphaCinemaContext(contextOptions)) { var command = new ProjectionService(actContext); await command.AddReservation(testUserId, testProjectionId); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { Assert.IsTrue(assertContext.WatchedMovies.Count() == 1); Assert.IsTrue(assertContext.WatchedMovies.First().UserId == testUserId); Assert.IsTrue(assertContext.WatchedMovies.First().ProjectionId == testProjectionId); } }
public async Task ThrowEntityDoesntExistExceptionWhenUserIsNotFound() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowEntityDoesntExistExceptionWhenUserIsNotFound") .Options; //Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var userService = new UserService(serviceProviderMock.Object, assertContext); await Assert.ThrowsExceptionAsync <EntityDoesntExistException>(() => userService.Modify("UserId")); } }
public async Task ThrowEntityDoesntExistExceptionWhenUserIsNull() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowEntityDoesntExistExceptionWhenUserIsNull") .Options; //Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var userService = new UserService(serviceProviderMock.Object, assertContext); await Assert.ThrowsExceptionAsync <EntityDoesntExistException>(() => userService.ChangePassword(user, It.IsAny <string>(), It.IsAny <string>())); } }
public async Task ThrowEntityDoesntExistException_WhenReservationDoesntExist() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowEntityDoesntExistException_WhenReservationDoesntExist") .UseInternalServiceProvider(serviceProvider) .Options; //Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new ProjectionService(assertContext); await Assert.ThrowsExceptionAsync <EntityDoesntExistException>(async() => await command.DeclineReservation(testUserId, testProjectionId)); } }
public async Task ThrowException_WhenMovieDoesntExist() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowException_WhenMovieDoesntExist") .UseInternalServiceProvider(serviceProvider) .Options; // Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new MovieService(assertContext); await Assert.ThrowsExceptionAsync <Exception>(async() => await command.DeleteMovie(testMovieOneName)); } }
public async Task ThrowEntityDoesntExistException_WhenMovieDesntExist() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowEntityDoesntExistException_WhenMovieDesntExist") .UseInternalServiceProvider(serviceProvider) .Options; //Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new MovieService(assertContext); await Assert.ThrowsExceptionAsync <EntityDoesntExistException>(async() => await command.UpdateMovie(movieId, newMovieName, newMovieDescription, newRealeaseYear, newMovieDuration, "")); } }
public async Task ReturnNullIfUserIdIsNotFound() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ReturnNullIfUserIdIsNotFound") .Options; // Act && Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var userService = new UserService(serviceProviderMock.Object, assertContext); var result = await userService.GetUser("no such id"); Assert.IsNull(result); } }
public async Task ThrowException_WhenMovieIsDeleted() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowException_WhenMovieIsDeleted") .UseInternalServiceProvider(serviceProvider) .Options; var listOfMovies = new List <Movie>() { testMovieOne, testMovieTwo, deletedMovie }; // Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new MovieService(assertContext); await Assert.ThrowsExceptionAsync <Exception>(async() => await command.DeleteMovie(deletedMovieName)); } }
public async Task Create_NewCity_When_CorrectParameters_ArePassed() { DbContextOptions <AlphaCinemaContext> contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "Create_NewCity_When_CorrectParameters_ArePassed") .Options; // Arrange var cityName = "TestCityName"; // Act && Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var cityServices = new CityService(assertContext); var city = await cityServices.AddCity(cityName); Assert.AreEqual(cityName, city.Name); } }
public async Task ReturnCollectionOfProjections_WhenCountIsValid() { //Arrange // Create a new options instance telling the context to use an InMemory database and the new service provider. var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ReturnCollectionOfProjections_WhenCountIsValid") .UseInternalServiceProvider(serviceProvider) .Options; var listOfProjections = new List <Projection>() { testProjectionOne, testProjectionTwo, testProjectionThree }; var listOfMovies = new List <Movie>() { testMovieOne, testMovieTwo, testMovieThree }; //Act and Assert using (var actContext = new AlphaCinemaContext(contextOptions)) { await actContext.AddRangeAsync(listOfProjections); await actContext.AddRangeAsync(listOfMovies); await actContext.AddAsync(testOpenHour); await actContext.AddAsync(testCity); await actContext.SaveChangesAsync(); } //Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new ProjectionService(assertContext); var result = await command.GetTopProjections(projectionCount); Assert.AreEqual(testProjectionOne.Id, result.First().Id); //We are returning the FirstProjection and we want the top 1 } }
public void AttachNewEntityToContext_WhenCalled() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "MarkEntityAsModified_WhenCalled") .Options; var testMovie = new Movie { Name = "TestMovie" }; //Act using (var context = new AlphaCinemaContext(contextOptions)) { var movieRepo = new Repository <Movie>(context); movieRepo.Update(testMovie); //Assert Assert.IsTrue(context.Set <Movie>().Local.Any(e => e == testMovie)); } }
public void MarkEntityAsModified_WhenCalled() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "MarkEntityAsModified_WhenCalled") .Options; var testMovie = new Movie { Name = "TestMovie" }; //Act using (var context = new AlphaCinemaContext(contextOptions)) { var movieRepo = new Repository <Movie>(context); movieRepo.Update(testMovie); EntityEntry entry = context.Entry(testMovie); //Assert Assert.AreEqual(EntityState.Modified, entry.State); } }
public void ChangeStateToUnchanged_WhenEntityIsAdded() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ChangeStateToAdded_WhenEntityIsModified") .Options; var testMovie = new Movie { Name = "TestMovie" }; //Act using (var context = new AlphaCinemaContext(contextOptions)) { var movieRepo = new Repository <Movie>(context); movieRepo.Add(testMovie); context.SaveChanges(); EntityEntry entry = context.Entry(testMovie); //Assert Assert.AreEqual(EntityState.Unchanged, entry.State); } }
public async Task ThrowException_WhenMovieAlreadyExist() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "ThrowException_WhenMovieAlreadyExist") .UseInternalServiceProvider(serviceProvider) .Options; using (var arrangeContext = new AlphaCinemaContext(contextOptions)) { await arrangeContext.AddAsync(movie); await arrangeContext.SaveChangesAsync(); } //Act and Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var command = new MovieService(assertContext); await Assert.ThrowsExceptionAsync <Exception>(async() => await command.AddMovie(movieName, movieDescription, releaseYear, movieDuration)); } }
public async Task SuccessfullyCreateNewWatchedMovieWhenParamsAreValid() { // Arrange contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "SuccessfullyCreateNewWatchedMovieWhenParamsAreValid") .Options; var userId = "djoni"; var projectionId = 6; // Act && Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { var watchedMoviesService = new WatchedMoviesService(assertContext); await watchedMoviesService.AddNewWatchedMovie(userId, projectionId); var watchedMovie = await watchedMoviesService.GetWatchedMovie(userId, projectionId); Assert.AreEqual(userId, watchedMovie.UserId); Assert.AreEqual(projectionId, watchedMovie.ProjectionId); } }
public void CityServices_ShouldDeleteCity_WhenPassedValidParameter() { // Arrange var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "CityServices_ShouldDeleteCity_WhenPassedValidParameter") .Options; City city = new City() { Name = "TestName", Id = 1, IsDeleted = false, Projections = new List <Projection>() }; var unitOfWorkMock = new Mock <IUnitOfWork>(); // Act using (var actContext = new AlphaCinemaContext(contextOptions)) { var cityServicesRepo = new Repository <City>(actContext); unitOfWorkMock .Setup(u => u.Cities) .Returns(cityServicesRepo); var sut = new CityServices(unitOfWorkMock.Object); sut.AddNewCity(city.Name); // first add a city sut.DeleteCity(city.Name); } // Assert using (var assertContext = new AlphaCinemaContext(contextOptions)) { Assert.IsTrue(assertContext.Cities.Count() == 1); Assert.AreEqual(assertContext.Cities.FirstOrDefault().IsDeleted, true); } }
public async Task Throw_EntityDoesntExistException_WhenCityDoesnotExists() { DbContextOptions <AlphaCinemaContext> contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>() .UseInMemoryDatabase(databaseName: "Throw_EntityDoesntExistException_WhenCityDoesnotExists") .Options; // Arrange var cityName = "TestCityName"; var city = new City() { Name = cityName }; using (var assertContext = new AlphaCinemaContext(contextOptions)) { var cityServices = new CityService(assertContext); await Assert.ThrowsExceptionAsync <EntityDoesntExistException>(() => cityServices.DeleteCity(cityName)); } }