public void AddUserShould_ThrowWhenCalledWithInvalidParameters()
{
// Arrange
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userDtoArgument = new UserModel()
{
FirstName = "John",
LastName = "Johnson",
Username = "******",
//Email = "*****@*****.**",
Password = "******"
};
var userObjectToReturn = new User()
{
FirstName = "John",
LastName = "Johnson",
Username = "******",
//Email = "*****@*****.**",
Password = "******"
};
mapperMock.Setup(x => x.Map <User>(It.IsAny <UserModel>()))
.Returns(userObjectToReturn);
var sut = new UserService(effort, mapperMock.Object);
// Act & Assert
Assert.ThrowsException <System.Data.Entity.Validation.DbEntityValidationException>(() => sut.AddUser(userDtoArgument));
}
public void AddMovieShouldCorrectlyAddMovieToDb_WhenCalledWithValidData()
{
// arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObjectToReturn = new Movie()
{
Title = "Test Movie Object",
Runtime = 120
};
mapperMock.Setup(x => x.Map <Movie>(It.IsAny <MovieModel>()))
.Returns(movieObjectToReturn);
var movieModelToAdd = new MovieModel()
{
Title = "Test Movie model",
Runtime = 120
};
// Act
var sut = new MovieService(effortContext, mapperMock.Object);
sut.AddMovie(movieModelToAdd);
Assert.AreEqual(1, effortContext.Movies.Count());
}
public void RemoveMovieShould_ThrowWhenMovieToRemoveNotFoundInDataBase()
{
// Arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObjectToRemove = new Movie()
{
Title = "Test title",
Runtime = 120
};
//effortContext.Movies.Add(movieObjectToRemove);
//effortContext.SaveChanges();
var movieDtoToRemove = new MovieModel()
{
MovieId = movieObjectToRemove.MovieId,
Title = movieObjectToRemove.Title,
Runtime = movieObjectToRemove.Runtime
};
var sut = new MovieService(effortContext, mapperMock.Object);
// Act & Assert
Assert.ThrowsException <ArgumentNullException>(() => sut.RemoveMovie(movieDtoToRemove));
}
public void GetUserShould_ReturnCorrectDataWhenCalledWithValidParmeters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
effort.Users.Add(userObject);
effort.SaveChanges();
var userDtoArgument = Mapper.Map <UserModel>(userObject);
mapperMock.Setup(x => x.Map <UserModel>(It.IsAny <User>()))
.Returns(userDtoArgument);
// Act
var sut = new UserService(effort, mapperMock.Object);
var result = sut.GetUserByUsername("Test");
// Assert
Assert.AreEqual("Test", result.Username);
}
public void GetUserShould_ThrowWhenCalledWithInvalidParmeters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
effort.Users.Add(userObject);
effort.SaveChanges();
var userDtoArgument = Mapper.Map <UserModel>(userObject);
mapperMock.Setup(x => x.Map <UserModel>(It.IsAny <User>()))
.Returns(userDtoArgument);
// Act
var sut = new UserService(effort, mapperMock.Object);
// Assert
Assert.ThrowsException <NullReferenceException>(() => sut.GetUserByUsername("Test_wrong"));
}
public void GiveReviewShouldCorrectlyAddReview_WhenInvokedWithValidParameters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
effort.Users.Add(userObject);
effort.SaveChanges();
var userIdToAdd = effort.Users
.Where(x => x.Username == "Test")
.FirstOrDefault()
.UserId;
var userDtoArgument = new UserModel()
{
UserId = userIdToAdd,
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var movie = new Movie()
{
Title = "Terminator",
Runtime = 150
};
userObject.BoughtMovies.Add(movie);
effort.SaveChanges();
//var userDtoArgument = Mapper.Map<UserModel>(userObject);
var movieDtoArgument = Mapper.Map <MovieModel>(movie);
mapperMock.Setup(x => x.Map <UserModel>(It.IsAny <User>()))
.Returns(userDtoArgument);
// Act
var sut = new UserService(effort, mapperMock.Object);
sut.GiveReview(userDtoArgument, movieDtoArgument, 10, "Very good movie!");
// Assert
var review = effort.Reviews.FirstOrDefault();
Assert.AreEqual(review.UserId, userDtoArgument.UserId);
}
public void AddMovieParticipantShouldCorrectlyAddParticipantToMovie_WhenCalledWithValidData()
{
// Assert
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObject = new Movie()
{
Title = "Test Movie",
Year = 1990
};
var participantObject = new Participant()
{
FirstName = "Arnold",
LastName = "Ivanov"
};
effort.Movies.Add(movieObject);
effort.Participants.Add(participantObject);
effort.SaveChanges();
var participantDto = new ParticipantModel()
{
ParticipantId = participantObject.ParticipantId,
FirstName = participantObject.FirstName,
LastName = participantObject.LastName
};
var movieDto = new MovieModel()
{
MovieId = movieObject.MovieId,
Title = movieObject.Title,
Runtime = movieObject.Runtime
};
var roleName = "Actor";
// Act
var sut = new MovieService(effort, mapperMock.Object);
sut.AddMovieParticipant(movieDto, participantDto, roleName);
// Assert
var participantAddedToMovie = movieObject.Participants.FirstOrDefault();
var movieAddedToParticipant = participantObject.Movies.FirstOrDefault();
var roleIsCorrect = effort.Roles.FirstOrDefault().RoleName == "Actor";
// Unit test should fail for only one reason
// either change the method to be SRP or separate the test into 3 parts
Assert.IsTrue(participantAddedToMovie == participantObject);
Assert.IsTrue(movieAddedToParticipant == movieObject);
Assert.IsTrue(roleIsCorrect);
}
public void GetActorsShould_ReturnCorrectValueWhenCalled()
{
// Arrange
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObject = new Movie()
{
Title = "Test Movie",
Year = 1990
};
effort.Movies.Add(movieObject);
for (int i = 0; i < 10; i++)
{
var participantObject = new Participant()
{
FirstName = "Test" + i,
LastName = "Testov"
};
var roleObject = new Role()
{
Movie = movieObject,
Participant = participantObject,
RoleName = "Actor"
};
effort.Participants.Add(participantObject);
effort.Roles.Add(roleObject);
}
effort.SaveChanges();
var participantDTOsListToReturn = Mapper.Map <IList <ParticipantModel> >(
effort.Participants);
var movieDtoArgument = Mapper.Map <MovieModel>(movieObject);
mapperMock.Setup(x => x.Map <IList <ParticipantModel> >(
It.IsAny <IList <Participant> >()))
.Returns(participantDTOsListToReturn);
// Act
var sut = new MovieService(effort, mapperMock.Object);
var result = sut.GetActors(movieDtoArgument);
// Assert
foreach (var actorPoco in effort.Participants)
{
var exists = result.Any(x => x.ParticipantId == actorPoco.ParticipantId);
Assert.IsTrue(exists);
}
}
public void GetDirectorsShould_ReturnCorrectValueWhenCalled()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObject = new Movie()
{
Title = "Test Movie",
Year = 1990
};
effort.Movies.Add(movieObject);
for (int i = 0; i < 10; i++)
{
var participantObject = new Participant()
{
FirstName = "Test" + i,
LastName = "Testov"
};
var roleObject = new Role()
{
Movie = movieObject,
Participant = participantObject,
RoleName = "Director"
};
effort.Participants.Add(participantObject);
effort.Roles.Add(roleObject);
}
effort.SaveChanges();
var expectedResult = effort.Roles
.Where(x => x.Movie.MovieId == movieObject.MovieId && x.RoleName == "Director")
.Select(p => p.Participant).ToList();
var movieDtoArgument = Mapper.Map <MovieModel>(movieObject);
// Act
var sut = new MovieService(effort, mapperMock.Object);
var result = sut.GetDirectors(movieDtoArgument);
// Assert
foreach (var p in expectedResult)
{
//var exists = result.Movies.Any(x => x.MovieId == movieDto.MovieId);
var exists = result.Any(x => x.ParticipantId == p.ParticipantId);
Assert.IsTrue(exists);
}
}
public void GetAllMoviesShould_ReturnCorrectDataWhenCalled()
{
// Arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
for (var i = 0; i < 10; i++)
{
var movieToAdd = new Movie()
{
Title = "Test title" + i,
Runtime = 120
};
effortContext.Movies.Add(movieToAdd);
}
effortContext.SaveChanges();
var moviesDTOsListToReturn = new List <MovieModel>();
foreach (var movie in effortContext.Movies)
{
var movieDto = new MovieModel()
{
MovieId = movie.MovieId,
Title = movie.Title,
Runtime = movie.Runtime
};
moviesDTOsListToReturn.Add(movieDto);
}
mapperMock.Setup(x => x.Map <IList <MovieModel> >(
It.IsAny <IList <Movie> >()))
.Returns(moviesDTOsListToReturn);
// Act
var sut = new MovieService(effortContext, mapperMock.Object);
var result = sut.GetAllMovies();
// Assert
//foreach (var movieDto in result)
//{
// var exists = effortContext.Movies.Any(x => x.MovieId == movieDto.MovieId);
// Assert.IsTrue(exists);
//}
// Or Another Assert - just checks if the count is the same
// both work - second is easier
Assert.AreEqual(10, result.Count());
}
public void GetAllUsersShould_ReturnCorrectDataWhenCalled()
{
// method Includes ProjecTo() call - will throw exception
// let it be for now
// for Toni
// Arrange
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
List <UserModel> userList = new List <UserModel>();
for (int i = 0; i < 10; i++)
{
var userObject = new User()
{
FirstName = "Test" + i,
LastName = "Testove" + i,
Username = "******" + i,
Email = "Test" + i + "@abv.com",
Password = "******"
};
effort.Users.Add(userObject);
var userToList = new UserModel()
{
FirstName = "Test" + i,
LastName = "Testove" + i,
Username = "******" + i,
Email = "Test" + i + "@abv.com",
Password = "******"
};
userList.Add(userToList);
}
effort.SaveChanges();
// Act
var sut = new UserService(effort, mapperMock.Object);
var result = sut.GetAllUsers();
// Assert
//foreach (var user in result)
//{
// var exists = userList.Any(x => x.Username == user.Username);
// Assert.IsTrue(exists);
//}
Assert.AreEqual(10, result.Count());
}
public void GetUsersWhoLikedMovieShould_ReturnCorrectValueWhenCalled()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObject = new Movie()
{
Title = "Test Movie",
Year = 1990
};
effort.Movies.Add(movieObject);
for (int i = 0; i < 10; i++)
{
var user = new User()
{
FirstName = "Pesho" + i,
LastName = "Peshev" + i,
Username = "******" + i,
Email = $"someMail{i}@mail.com",
Password = $"somepassword{i}"
};
effort.Users.Add(user);
movieObject.LikedBy.Add(user);
}
effort.SaveChanges();
var expectedResult = effort.Movies
.Where(x => x.Title == "Test Movie")
.FirstOrDefault()
.LikedBy
.ToList();
var movieDtoArgument = Mapper.Map <MovieModel>(movieObject);
// Act
var sut = new MovieService(effort, mapperMock.Object);
var result = sut.GetUsersWhoLikedtIt(movieDtoArgument);
// Assert
//Assert.AreEqual(10, result.Count()); Also works OK
foreach (var p in expectedResult)
{
var exists = result.Any(x => x.Username == p.Username);
Assert.IsTrue(exists);
}
}
public void GetMovieGenresShould_ReturnCorrectValueWhenCalled()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObject = new Movie()
{
Title = "Test Movie",
Year = 1990
};
effort.Movies.Add(movieObject);
for (int i = 0; i < 10; i++)
{
var genre = new Genre()
{
GenreType = "SomeGenre" + i
};
effort.Genres.Add(genre);
movieObject.Genres.Add(genre);
}
effort.SaveChanges();
var expectedResult = effort.Movies
.Where(x => x.Title == "Test Movie")
.FirstOrDefault()
.Genres
.ToList();
var movieDtoArgument = Mapper.Map <MovieModel>(movieObject);
// Act
var sut = new MovieService(effort, mapperMock.Object);
var result = sut.GetMovieGenres(movieDtoArgument);
// Assert
//Assert.AreEqual(10, result.Count()); Also works OK
foreach (var p in expectedResult)
{
var exists = result.Any(x => x.GenreType == p.GenreType);
Assert.IsTrue(exists);
}
}
public static void Main()
{
var context = new MovieAppDBContext();
if (!context.Movies.Any())
{
string moviesPath = @"..\..\..\SquidsMovieApp.Data\Utilities\JsonData\movies.json";
var parser = new Parser();
var webConverter = new WebConverter();
var movies = parser.ParseMovies(moviesPath);
var converter = new MovieConverter(context, webConverter, parser);
converter.AddOrUpdateMovies(movies);
}
}
public void BuyMovieShouldCorrectlyAddSelectedMovieToUserBoughtMoviesCollection_WhenInvokedWithValidParameters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
effort.Users.Add(userObject);
effort.SaveChanges();
List <Movie> boughtMovies = new List <Movie>();
for (int i = 0; i < 10; i++)
{
var movie = new Movie()
{
Title = "Terminator" + i,
Runtime = 150
};
userObject.BoughtMovies.Add(movie);
effort.SaveChanges();
boughtMovies.Add(movie);
}
var userDtoArgument = Mapper.Map <UserModel>(userObject);
mapperMock.Setup(x => x.Map <UserModel>(It.IsAny <User>()))
.Returns(userDtoArgument);
// Act
var sut = new UserService(effort, mapperMock.Object);
var result = sut.GetBoughtMovies(userDtoArgument);
// Assert
foreach (var movie in result)
{
bool areSame = boughtMovies.Any(x => x.Title == movie.Title);
Assert.IsTrue(areSame);
}
}
public void AddMoneyToBalanceShould_CorrectlyAddMoneyToUserWhenInvokedWithValidParameters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
effort.Users.Add(userObject);
effort.SaveChanges();
var userIdToAdd = effort.Users
.Where(x => x.Username == "TestOne")
.FirstOrDefault()
.UserId;
var userDtoArgument = new UserModel()
{
UserId = userIdToAdd,
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
// Act
var sut = new UserService(effort, mapperMock.Object);
sut.AddMoneyToBalance(userDtoArgument, 5000M);
//var money = sut.GetMoneyBalance(userDtoArgument);
// Assert
Assert.AreEqual(6000M, userObject.MoneyBalance);
}
public void RemoveUserShould_CorrectlyRemoveUserFromDbWhenCalleWithValidData()
{
// Arrange
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObjectToReturn = new User()
{
FirstName = "John",
LastName = "Johnson",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
effort.Users.Add(userObjectToReturn);
effort.SaveChanges();
var userID = effort.Users
.Where(x => x.Username == "HackMan")
.FirstOrDefault()
.UserId;
var userDtoArgument = new UserModel()
{
UserId = userID,
FirstName = "John",
LastName = "Johnson",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
mapperMock.Setup(x => x.Map <User>(It.IsAny <UserModel>()))
.Returns(userObjectToReturn);
// Act
var sut = new UserService(effort, mapperMock.Object);
sut.RemoveUser(userDtoArgument);
effort.SaveChanges();
// Assert
Assert.AreEqual(0, effort.Users.Count());
}
public void GetLikedParticipantsShould_ReturnCorrectResultWhenCalled()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
effort.Users.Add(userObject);
for (int i = 0; i < 10; i++)
{
var participant = new Participant()
{
FirstName = "John" + i,
LastName = "Johnson" + i
};
effort.Participants.Add(participant);
userObject.LikedParticipants.Add(participant);
}
effort.SaveChanges();
// replace with manual map
var userDtoArgument = Mapper.Map <UserModel>(userObject);
// Act
var sut = new UserService(effort, mapperMock.Object);
var result = sut.GetLikedParticipants(userDtoArgument);
// Assert
foreach (var p in userObject.LikedParticipants)
{
var exists = result.Any(x => x.ParticipantId == p.ParticipantId);
Assert.IsTrue(exists);
}
}
public void RemoveUserShould_ThrowWhenUserNotFoundInDataBase()
{
// Arrange
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObjectToReturn = new User()
{
FirstName = "John",
LastName = "Johnson",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
//effort.Users.Add(userObjectToReturn);
//effort.SaveChanges();
var userID = effort.Users
.Where(x => x.Username == "HackMan")
.FirstOrDefault()
.UserId;
var userDtoArgument = new UserModel()
{
//UserId = userID,
FirstName = "John",
LastName = "Johnson",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
mapperMock.Setup(x => x.Map <User>(It.IsAny <UserModel>()))
.Returns(userObjectToReturn);
// Act
var sut = new UserService(effort, mapperMock.Object);
// Assert
Assert.ThrowsException <System.NullReferenceException>(() => sut.RemoveUser(userDtoArgument));
}
public void AddMovieShould_ThrowWhenCalledWithInvalidData()
{
// arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObjectToReturn = new Movie()
{
Title = "Test Movie Object",
Runtime = 120
};
mapperMock.Setup(x => x.Map <Movie>(It.IsAny <MovieModel>()))
.Returns(movieObjectToReturn);
var movieToAdd = new MovieModel();
var sut = new MovieService(effortContext, mapperMock.Object);
// Act & Assert
Assert.ThrowsException <ArgumentException>(() => sut.AddMovie((movieToAdd)));
}
public void AddUserShould_CorrectlyAddUserToDataBaseWhenCalledWithValidParameters()
{
// Arrange
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userDtoArgument = new UserModel()
{
FirstName = "John",
LastName = "Johnson",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var userObjectToReturn = new User()
{
FirstName = "John",
LastName = "Johnson",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
mapperMock.Setup(x => x.Map <User>(It.IsAny <UserModel>()))
.Returns(userObjectToReturn);
// Act
var sut = new UserService(effort, mapperMock.Object);
sut.AddUser(userDtoArgument);
// Assert
Assert.AreEqual(1, effort.Users.Count());
}
public void RemoveMovieShould_CorrectlyRemoveMovieFromDB()
{
// Arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var movieObjectToRemove = new Movie()
{
Title = "Test title",
Runtime = 120
};
effortContext.Movies.Add(movieObjectToRemove);
effortContext.SaveChanges();
// when testing do not use automapper - you are coupling yourself
// to autommaper and if its broken/ or you change it - the test will
// also fail - so do it manually
//var movieDtoToRemove = Mapper.Map<MovieModel>(movieObjectToRemove);
var movieDtoToRemove = new MovieModel()
{
MovieId = movieObjectToRemove.MovieId,
Title = movieObjectToRemove.Title,
Runtime = movieObjectToRemove.Runtime
};
// Act
var sut = new MovieService(effortContext, mapperMock.Object);
sut.RemoveMovie(movieDtoToRemove);
//Assert
Assert.AreEqual(0, effortContext.Movies.Count());
}
public MovieConverter(MovieAppDBContext ctx, WebConverter webConverter, Parser parser)
{
this.ctx = ctx;
this.webConverter = webConverter;
this.parser = parser;
}
public void AddMovieParticipantShouldSucessfullyInvokeService_WhenCalledWithValidParameters()
{
//Arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mockMovieService = new Mock <IMovieService>();
var mockRoleService = new Mock <IRoleService>();
var mockMapper = new Mock <IMapper>();
var mockFactory = new Mock <IMovieModelFactory>();
var movieObjectToReturn = new Movie()
{
Title = "TestMovie",
Runtime = 120
};
var movieModelToAdd = new MovieModel()
{
Title = "TestMovie",
Runtime = 120
};
mockMapper.Setup(x => x.Map <MovieModel>(It.IsAny <Movie>()))
.Returns(movieModelToAdd);
var participantModelToAdd = new ParticipantModel()
{
FirstName = "Pesho",
LastName = "Markov",
Age = 21
};
var participantObjectToReturn = new Participant()
{
FirstName = "Pesho",
LastName = "Markov",
Age = 21
};
var roles = new List <Role>();
roles.Add(new Role()
{
RoleName = "Terminator"
});
var listOfAllParticipants = new List <ParticipantModel>();
listOfAllParticipants.Add(participantModelToAdd);
mockMapper.Setup(x => x.Map <ParticipantModel>(It.IsAny <Participant>()))
.Returns(participantModelToAdd);
mockMovieService.Setup(x => x.AddMovieParticipant(It.IsAny <MovieModel>(), It.IsAny <ParticipantModel>(), It.IsAny <string>()))
.Verifiable();
mockMovieService.Setup(x => x.GetMovieByTitle(It.IsAny <string>()))
.Returns(movieModelToAdd);
mockMovieService.Setup(x => x.GetAllParticipantsPerMovie(It.IsAny <MovieModel>()))
.Returns(listOfAllParticipants);
mockRoleService.Setup(x => x.ParticipantRolesPerMovie(It.IsAny <ParticipantModel>(), It.IsAny <MovieModel>()))
.Returns(roles);
effortContext.Participants.Add(participantObjectToReturn);
effortContext.Movies.Add(movieObjectToReturn);
effortContext.SaveChanges();
var controller = new MovieController(mockMovieService.Object,
mockRoleService.Object, mockMapper.Object, mockFactory.Object);
// Act
controller.AddMovieParticipant("TestMovie", "Pesho", "Markov", "someRole");
// Assert TODO
mockMovieService.Verify(x => x.AddMovieParticipant(It.IsAny <MovieModel>(), It.IsAny <ParticipantModel>(), It.IsAny <string>()), Times.Once);
}
public void GetFollowed_ShouldReturnCorrectDataWhenCaledWithValidParameters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
effort.Users.Add(userObject);
effort.SaveChanges();
var userIdToAdd = effort.Users
.Where(x => x.Username == "TestOne")
.FirstOrDefault()
.UserId;
var userDtoArgument = new UserModel()
{
UserId = userIdToAdd,
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
List <User> followedList = new List <User>();
for (int i = 0; i < 10; i++)
{
var user = new User()
{
FirstName = "Test" + i,
LastName = "Testove" + i,
Username = "******" + i,
Email = "Test" + i + "@abv.com",
Password = "******"
};
effort.Users.Add(user);
userObject.Following.Add(user);
followedList.Add(user);
effort.SaveChanges();
}
//var userDtoArgument = Mapper.Map<UserModel>(userObject);
//mapperMock.Setup(x => x.Map<UserModel>(It.IsAny<User>()))
// .Returns(userDtoArgument);
// Act
var sut = new UserService(effort, mapperMock.Object);
var results = sut.GetFollowed(userDtoArgument);
// Assert
foreach (var user in results)
{
bool areSame = followedList.Any(x => x.Username == user.Username);
Assert.IsTrue(areSame);
}
}
public void LikeParticipantShould_CorrectlyAddParticipantWhenInvokedWithValidParameters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
var participantObject = new Participant()
{
FirstName = "participantFirstName",
LastName = "participantLastName",
Age = 30
};
effort.Users.Add(userObject);
effort.Participants.Add(participantObject);
effort.SaveChanges();
var userIdToAdd = effort.Users
.Where(x => x.Username == "TestOne")
.FirstOrDefault()
.UserId;
var userDtoArgument = new UserModel()
{
UserId = userIdToAdd,
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
var participantIdToAdd = effort.Participants
.Where(x => x.FirstName == "participantFirstName")
.FirstOrDefault()
.ParticipantId;
var participantDtoArgument = new ParticipantModel()
{
ParticipantId = participantIdToAdd,
FirstName = "participantFirstName",
LastName = "participantLastName",
Age = 30
};
// Act
var sut = new UserService(effort, mapperMock.Object);
sut.LikeParticipant(userDtoArgument, participantDtoArgument);
var likedParticipant = effort.Users
.Where(x => x.UserId == userIdToAdd)
.FirstOrDefault()
.LikedParticipants
.FirstOrDefault();
// Assert
Assert.AreEqual(likedParticipant.FirstName, participantDtoArgument.FirstName);
}
public void FollowUserShould_CorrectlyAddSelectedUserToFollowedCollectionWhenInvokedWithValidParameters()
{
// Act
var effort = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var userObject = new User()
{
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
effort.Users.Add(userObject);
effort.SaveChanges();
var userIdToAdd = effort.Users
.Where(x => x.Username == "TestOne")
.FirstOrDefault()
.UserId;
var userDtoArgument = new UserModel()
{
UserId = userIdToAdd,
FirstName = "Test",
LastName = "Testove",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
var userToFollow = new User()
{
FirstName = "TestFollow",
LastName = "TestoveFollow",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
effort.Users.Add(userToFollow);
effort.SaveChanges();
var userToFollowIdToAdd = effort.Users
.Where(x => x.Username == "TestOneFollow")
.FirstOrDefault()
.UserId;
var userToFollowDtoArgument = new UserModel()
{
UserId = userToFollowIdToAdd,
FirstName = "TestFollow",
LastName = "TestoveFollow",
Username = "******",
Email = "*****@*****.**",
Password = "******",
MoneyBalance = 1000
};
// Act
var sut = new UserService(effort, mapperMock.Object);
sut.FollowUser(userDtoArgument, userToFollowDtoArgument);
var followedUser = effort.Users
.Where(x => x.UserId == userDtoArgument.UserId)
.FirstOrDefault()
.Following
.FirstOrDefault();
// Assert
Assert.AreEqual(followedUser.UserId, userToFollowDtoArgument.UserId);
}
public void GetAllParticipantsPerMovieShould_ReturnCorrectParticipants()
{
// Arrange
var effortContext = new MovieAppDBContext(
Effort.DbConnectionFactory.CreateTransient());
var mapperMock = new Mock <IMapper>();
var sut = new MovieService(effortContext, mapperMock.Object);
var movieToAdd = new Movie()
{
Title = "Test title",
Runtime = 120
};
var movieDto = new MovieModel()
{
MovieId = movieToAdd.MovieId,
Title = movieToAdd.Title,
Runtime = movieToAdd.Runtime
};
effortContext.Movies.Add(movieToAdd);
for (int i = 0; i < 10; i++)
{
var participant = new Participant()
{
FirstName = "FirstName" + i,
LastName = "LastName" + i
};
effortContext.Participants.Add(participant);
participant.Movies.Add(movieToAdd);
var participant2 = effortContext.Participants
.Where(x => x.FirstName == "FirstName" + i)
.FirstOrDefault();
movieToAdd.Participants.Add(participant2);
sut.AddMovieParticipant(movieDto, new ParticipantModel()
{
FirstName = participant.FirstName,
LastName = participant.LastName
},
$"someRole + {i}");
effortContext.SaveChanges();
}
var participantsDTOsListToReturn = new List <ParticipantModel>();
//effortContext.SaveChanges();
mapperMock.Setup(x => x.Map <IList <ParticipantModel> >(
It.IsAny <IList <Participant> >()))
.Returns(participantsDTOsListToReturn);
// Act & Assert
var result = sut.GetAllParticipantsPerMovie(movieDto);
Assert.AreEqual(10, result.Count());
}
