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));
}
}
