public void Clone_ShouldDuplicateEveryValue()
{
var friendship = ModelTestHelper.CreateFriendship(3, "forClone", new DateTime(2017, 03, 05),
true, false);
TestClone(friendship);
}
public void AcceptFriendship_WhenException_ShouldRollback()
{
var firstUser = ModelTestHelper.CreateUser(-1, "aUser");
var secondUser = ModelTestHelper.CreateUser(-1, "aFriend", "secondEmail");
var userRepo = new UserRepository();
userRepo.SaveUser(firstUser);
Assert.IsFalse(userRepo.HasErrors);
userRepo.SaveUser(secondUser);
Assert.IsFalse(userRepo.HasErrors);
var friendship = ModelTestHelper.CreateFriendship(firstUser.Id, secondUser.Pseudo, DateTime.Now, true, true);
var service = new FriendshipServices();
service.RequestFriendship(friendship, firstUser.Pseudo);
Assert.IsFalse(service.HasErrors);
var mock = new Mock <IUserRepository>();
mock.SetupGet(u => u.HasErrors).Throws(new Exception("Rollback"));
var mockService = new FriendshipServices(mock.Object, new FriendshipRepository());
mockService.AcceptFriendship(friendship, firstUser.Pseudo);
Assert.IsTrue(mockService.HasErrors);
var dbFriendship = service.GetFriendship(friendship.UserId, friendship.FriendName);
Assert.IsTrue(dbFriendship.IsWaiting);
}
public void ToString_ShouldUseAgeAndPseudo()
{
var user = ModelTestHelper.CreateUser(1, "ToStringPseudo");
var expected = string.Format("{0}, {1}", user.Pseudo, user.Age);
Assert.AreEqual(expected, user.ToString());
}
public void AcceptFriendship_WhenValid_ShouldCommit()
{
var firstUser = ModelTestHelper.CreateUser(-1, "aUser");
var secondUser = ModelTestHelper.CreateUser(-1, "aFriend", "secondEmail");
var userRepo = new UserRepository();
userRepo.SaveUser(firstUser);
Assert.IsFalse(userRepo.HasErrors);
userRepo.SaveUser(secondUser);
Assert.IsFalse(userRepo.HasErrors);
var friendship = ModelTestHelper.CreateFriendship(firstUser.Id, secondUser.Pseudo, DateTime.Now, true, true);
var service = new FriendshipServices();
service.RequestFriendship(friendship, firstUser.Pseudo);
Assert.IsFalse(service.HasErrors);
service.AcceptFriendship(friendship, firstUser.Pseudo);
Assert.IsFalse(service.HasErrors);
var dbFriendship = service.GetFriendship(friendship.UserId, friendship.FriendName);
Assert.IsNotNull(dbFriendship);
Assert.IsFalse(dbFriendship.IsWaiting);
var otherFriendship = service.GetFriendship(secondUser.Id, firstUser.Pseudo);
Assert.IsNotNull(otherFriendship);
Assert.IsFalse(dbFriendship.IsWaiting);
}
public void DeleteUser_WhenUnableToDeleteOtherFriendship_ShouldLogError()
{
var errors = new List <string> {
"unable to delete other friendship"
};
var user = ModelTestHelper.CreateUser(1, "first");
user.AddFriend(ModelTestHelper.CreateFriendship(user.Id, "aFriend"));
_mockUserRepo.Setup(s => s.GetUserInfo("aFriend")).Returns(() => ModelTestHelper.CreateUser(2, "aFriend"));
_mockUserRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockUserRepo.SetupGet(g => g.Errors).Returns(new List <string>());
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
var otherFriendship = ModelTestHelper.CreateFriendship(2, user.Pseudo);
_mockFriendshipRepo.Setup(s => s.GetFriendship(2, user.Pseudo)).Returns(() => otherFriendship);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(errors);
_mockFriendshipRepo.Setup(s => s.DeleteFriendship(user.Friends.First())).Callback
(
() => _mockFriendshipRepo.Setup(s => s.HasErrors).Returns(false)
);
_mockFriendshipRepo.Setup(s => s.DeleteFriendship(otherFriendship)).Callback
(
() => _mockFriendshipRepo.Setup(s => s.HasErrors).Returns(true)
);
CreateUserServices();
_userServices.DeleteUser(user);
Assert.IsTrue(_userServices.HasErrors);
Assert.IsTrue(_userServices.Errors.Contains("unable to delete other friendship"));
}
public void LoginByMail_WhenValid_ShouldNotLogError()
{
var user = ModelTestHelper.CreateUser(1, "toto");
_mockUserRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockUserRepo.Setup(s => s.GetUserByMail(user.Mail, user.Password)).Returns(user);
_mockUserRepo.SetupGet(s => s.Errors).Returns(new List <string>());
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockFriendshipRepo.Setup(s => s.GetUserFriendships(user.Id))
.Returns(new List <Friendship> {
ModelTestHelper.CreateFriendship(user.Id, "aFriend")
});
_mockTripRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockTripRepo.Setup(s => s.GetUserTrips(user.Id))
.Returns(new List <UserTrip> {
ModelTestHelper.CreateUserTrip(user.Id, "aTrip")
});
CreateUserServices();
var dbUser = _userServices.LoginByMail(user.Mail, user.Password);
Assert.IsFalse(_userServices.HasErrors);
Assert.IsNotNull(dbUser);
Assert.AreEqual(1, dbUser.Friends.Count());
Assert.AreEqual(1, dbUser.Trips.Count());
}
public void UpdatePrice_WhenValid_ShouldCommit()
{
var trip = ModelTestHelper.CreateTrip(-1, "UpdatePriceValid", 1000, maxNbPeople: 30);
var services = new TripServices();
services.CreateTrip(trip, 1);
Assert.IsFalse(services.HasErrors);
var reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(1, reloadedTrip.Participants.Count());
services.UpdatePrice(reloadedTrip, 2000.26);
reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(2000.26, reloadedTrip.Price);
Assert.IsNotNull(reloadedTrip.TripPot);
Assert.AreEqual(2000.26, reloadedTrip.TripPot.TargetAmount);
var potUser = new PotUserRepository().GetPotUser(reloadedTrip.TripPot.Id, 1);
Assert.IsNotNull(potUser);
Assert.AreEqual(2000.26 / reloadedTrip.NumberMaxOfPeople, potUser.TargetAmount);
var userTrip = new UserTripRepository().GetUserTrip(1, trip.TripName);
Assert.IsNotNull(userTrip);
Assert.AreEqual(2000.26, userTrip.TripAmount);
}
public void CreateTrip_WhenValid_ShouldCommit()
{
var trip = ModelTestHelper.CreateTrip(-1, "createTripCommit", organizer: "aUser");
var userTripRepo = new UserTripRepository();
var services = new TripServices();
services.CreateTrip(trip, 1);
Assert.IsFalse(services.HasErrors);
var dbTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(dbTrip);
Assert.IsNotNull(dbTrip.TripPot);
var pot = dbTrip.TripPot;
Assert.AreEqual(trip.Price, pot.TargetAmount);
Assert.AreEqual(1, dbTrip.Participants.Count());
var ptp = dbTrip.Participants.First();
Assert.AreEqual(dbTrip.Id, ptp.TripId);
Assert.AreEqual(1, pot.Participants.Count());
var potUser = pot.Participants.First();
Assert.AreEqual(pot.Id, potUser.PotId);
var userTrips = userTripRepo.GetUserTripsByTrip(trip.TripName);
Assert.IsFalse(userTripRepo.HasErrors);
Assert.AreEqual(1, userTrips.Count());
var userTrip = userTrips.First();
Assert.AreEqual(trip.TripName, userTrip.TripName);
}
public void UpdateAllowedNumberOfPeople_WhenException_ShouldRollback()
{
var trip = ModelTestHelper.CreateTrip(-1, "UpdateNbPeopleException", 1000, maxNbPeople: 30);
var services = new TripServices();
services.CreateTrip(trip, 1);
Assert.IsFalse(services.HasErrors);
var reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(1, reloadedTrip.Participants.Count());
var mockTripRepo = new Mock <ITripRepository>();
mockTripRepo.Setup(s => s.UpdateTrip(reloadedTrip)).Throws(new Exception("ExceptionForTest"));
var secondServices = new TripServices(mockTripRepo.Object, new PotRepository(), new TripParticipantRepository(),
new UserTripRepository(), new PotUserRepository());
secondServices.UpdateAllowedNumberOfPeople(trip, 50);
Assert.IsTrue(secondServices.HasErrors);
reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(30, reloadedTrip.NumberMaxOfPeople);
var potUser = new PotUserRepository().GetPotUser(reloadedTrip.TripPot.Id, 1);
Assert.IsNotNull(potUser);
Assert.AreEqual(reloadedTrip.Price / 30, potUser.TargetAmount);
}
public void UpdatePrice_WhenError_ShouldRollback()
{
var trip = ModelTestHelper.CreateTrip(-1, "UpdatePriceError", 1000, maxNbPeople: 30);
var services = new TripServices();
services.CreateTrip(trip, 1);
Assert.IsFalse(services.HasErrors);
var reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(1, reloadedTrip.Participants.Count());
var mockTripRepo = new Mock <ITripRepository>();
mockTripRepo.Setup(s => s.UpdateTrip(reloadedTrip)).Callback(() => new TripRepository().UpdateTrip(reloadedTrip));
mockTripRepo.SetupGet(s => s.HasErrors).Returns(true);
mockTripRepo.SetupGet(s => s.Errors).Returns(new List <string>());
var secondServices = new TripServices(mockTripRepo.Object, new PotRepository(), new TripParticipantRepository(),
new UserTripRepository(), new PotUserRepository());
secondServices.UpdatePrice(trip, 2000.26);
Assert.IsTrue(secondServices.HasErrors);
reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(1000, reloadedTrip.Price);
Assert.IsNotNull(reloadedTrip.TripPot);
Assert.AreEqual(1000, reloadedTrip.TripPot.TargetAmount);
var potUser = new PotUserRepository().GetPotUser(reloadedTrip.TripPot.Id, 1);
Assert.IsNotNull(potUser);
Assert.AreEqual(1000 / (double)reloadedTrip.NumberMaxOfPeople, potUser.TargetAmount);
var userTrip = new UserTripRepository().GetUserTrip(1, trip.TripName);
Assert.IsNotNull(userTrip);
Assert.AreEqual(1000, userTrip.TripAmount);
}
public void Quit_WhenError_ShouldRollback()
{
var trip = ModelTestHelper.CreateTrip(-1, "QuitError");
var services = new TripServices();
var userTrip = ModelTestHelper.CreateUserTrip(2, trip.TripName);
services.CreateTrip(trip, 1);
Assert.IsFalse(services.HasErrors);
var reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(1, reloadedTrip.Participants.Count());
services.Participate(reloadedTrip, 2, "aSecondUser");
Assert.IsFalse(services.HasErrors, string.Join(",", services.Errors));
var mockUserTripRepo = new Mock <IUserTripRepository>();
mockUserTripRepo.Setup(s => s.GetUserTrip(2, reloadedTrip.TripName)).Returns(userTrip);
mockUserTripRepo.Setup(s => s.HasErrors).Returns(true);
mockUserTripRepo.Setup(s => s.Errors).Returns(new List <string>());
var secondServices = new TripServices(new TripRepository(), new PotRepository(), new TripParticipantRepository(),
mockUserTripRepo.Object, new PotUserRepository());
secondServices.Quit(reloadedTrip, 2, "aSecondUser");
Assert.IsTrue(secondServices.HasErrors);
Assert.AreEqual(2, services.GetParticipants(reloadedTrip.Id).Count());
}
public void DeleteTrip_WhenValid_ShouldCommit()
{
var trip = ModelTestHelper.CreateTrip(-1, "deleteTripCommit");
var services = new TripServices();
services.CreateTrip(trip, 1);
Assert.IsFalse(services.HasErrors);
var reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
var pot = reloadedTrip.TripPot;
Assert.IsNotNull(pot);
var participants = reloadedTrip.Participants;
Assert.AreEqual(1, participants.Count());
var potUsers = pot.Participants;
Assert.AreEqual(1, potUsers.Count());
var tripRepo = new TripRepository();
var potRepo = new PotRepository();
var userTripRepo = new UserTripRepository();
var potUserRepo = new PotUserRepository();
var tripParticipantRepo = new TripParticipantRepository();
services.DeleteTrip(reloadedTrip);
Assert.IsFalse(services.HasErrors);
Assert.IsNull(tripRepo.GetTrip(reloadedTrip.Id));
Assert.IsNull(potRepo.GetPot(pot.Id));
Assert.AreEqual(0, userTripRepo.GetUserTripsByTrip(reloadedTrip.TripName).Count());
Assert.AreEqual(0, potUserRepo.GetPotUsers(pot.Id).Count());
Assert.AreEqual(0, tripParticipantRepo.GetTripParticipants(reloadedTrip.Id).Count());
}
public void DeleteTrip_WhenError_ShouldRollback()
{
var trip = ModelTestHelper.CreateTrip(-1, "deleteTripError");
var services = new TripServices();
services.CreateTrip(trip, 1);
Assert.IsFalse(services.HasErrors);
var reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
var userTrip = ModelTestHelper.CreateUserTrip(1, trip.TripName);
var mockUserTripRepo = new Mock <IUserTripRepository>();
mockUserTripRepo.Setup(s => s.GetUserTripsByTrip(trip.TripName)).Returns(new List <UserTrip> {
userTrip
});
mockUserTripRepo.SetupGet(s => s.HasErrors).Returns(true);
mockUserTripRepo.SetupGet(s => s.Errors).Returns(new List <string>());
var secondServices = new TripServices(new TripRepository(), new PotRepository(), new TripParticipantRepository(),
mockUserTripRepo.Object, new PotUserRepository());
secondServices.DeleteTrip(reloadedTrip);
Assert.IsTrue(secondServices.HasErrors);
reloadedTrip = services.GetTrip(trip.Id);
Assert.IsNotNull(reloadedTrip);
Assert.AreEqual(1, reloadedTrip.Participants.Count());
}
public void Credit_WhenValid_ShouldCommit()
{
var pot = ModelTestHelper.CreatePot(-1, 1, amount: 200);
var potRepo = new PotRepository();
potRepo.SavePot(pot);
Assert.IsFalse(potRepo.HasErrors);
var potUser = ModelTestHelper.CreatePotUser(1, pot.Id, amount: 0, targetAmount: 200);
var potUserRepo = new PotUserRepository();
potUserRepo.SavePotUser(potUser);
Assert.IsFalse(potUserRepo.HasErrors);
var services = new PotServices();
services.Credit(pot, 1, 200);
Assert.IsFalse(services.HasErrors);
var dbPot = services.GetPot(pot.Id);
Assert.IsNotNull(dbPot);
Assert.AreEqual(400, dbPot.CurrentAmount);
Assert.AreEqual(1, dbPot.Participants.Count());
var member = dbPot.Participants.FirstOrDefault();
Assert.IsNotNull(member);
Assert.AreEqual(200, member.Amount);
Assert.IsTrue(member.HasPayed);
}
public void DenyFriendship_WhenError_ShouldRollback()
{
var firstUser = ModelTestHelper.CreateUser(-1, "aUser");
var secondUser = ModelTestHelper.CreateUser(-1, "aFriend", "secondEmail");
var userRepo = new UserRepository();
userRepo.SaveUser(firstUser);
Assert.IsFalse(userRepo.HasErrors);
userRepo.SaveUser(secondUser);
Assert.IsFalse(userRepo.HasErrors);
var friendship = ModelTestHelper.CreateFriendship(firstUser.Id, secondUser.Pseudo, DateTime.Now, true, true);
var service = new FriendshipServices();
service.RequestFriendship(friendship, firstUser.Pseudo);
Assert.IsFalse(service.HasErrors);
var mock = new Mock <IUserRepository>();
mock.SetupGet(u => u.HasErrors).Returns(false);
mock.Setup(s => s.GetUserInfo(It.IsAny <string>())).Returns(() => null);
var mockService = new FriendshipServices(mock.Object, new FriendshipRepository());
mockService.DenyFriendship(friendship, firstUser.Pseudo);
Assert.IsTrue(mockService.HasErrors);
var dbFriendship = service.GetFriendship(friendship.UserId, friendship.FriendName);
Assert.IsNotNull(dbFriendship);
}
public void Credit_WhenErrorDuringUpdate_ShouldRollback()
{
var pot = ModelTestHelper.CreatePot(-1, 1, amount: 200);
var potRepo = new PotRepository();
potRepo.SavePot(pot);
Assert.IsFalse(potRepo.HasErrors);
var potUser = ModelTestHelper.CreatePotUser(1, pot.Id, amount: 0, targetAmount: 200);
var potUserRepo = new PotUserRepository();
potUserRepo.SavePotUser(potUser);
Assert.IsFalse(potUserRepo.HasErrors);
var mockPotRepo = new Mock <IPotRepository>();
mockPotRepo.SetupGet(s => s.HasErrors).Returns(true);
mockPotRepo.SetupGet(s => s.Errors).Returns(new List <string> {
"an error"
});
var services = new PotServices(mockPotRepo.Object, new PotUserRepository());
services.Credit(pot, 1, 200);
Assert.IsTrue(services.HasErrors);
services = new PotServices();
var dbPot = services.GetPot(pot.Id);
Assert.IsNotNull(dbPot);
Assert.AreEqual(200, dbPot.CurrentAmount);
Assert.AreEqual(1, dbPot.Participants.Count());
var member = dbPot.Participants.First();
Assert.IsNotNull(member);
Assert.AreEqual(0, member.Amount);
}
public void Clone_ShouldDuplicateValues()
{
var ptp = ModelTestHelper.CreateTripParticipant(1, "forClone", true, 4.5,
new DateTime(2017, 03, 06));
TestClone(ptp);
}
public void Credit_WhenException_ShouldRollback()
{
var pot = ModelTestHelper.CreatePot(-1, 1, amount: 200);
var potRepo = new PotRepository();
potRepo.SavePot(pot);
Assert.IsFalse(potRepo.HasErrors);
var potUser = ModelTestHelper.CreatePotUser(1, pot.Id, amount: 0, targetAmount: 200);
var potUserRepo = new PotUserRepository();
potUserRepo.SavePotUser(potUser);
Assert.IsFalse(potUserRepo.HasErrors);
var mockPotRepo = new Mock <IPotRepository>();
mockPotRepo.Setup(s => s.UpdatePot(It.IsAny <Pot>())).Throws(new Exception("Exception"));
var services = new PotServices(mockPotRepo.Object, new PotUserRepository());
services.Credit(pot, 1, 200);
Assert.IsTrue(services.HasErrors);
services = new PotServices();
var dbPot = services.GetPot(pot.Id);
Assert.IsNotNull(dbPot);
Assert.AreEqual(200, dbPot.CurrentAmount);
Assert.AreEqual(1, dbPot.Participants.Count());
var member = dbPot.Participants.First();
Assert.IsNotNull(member);
Assert.AreEqual(0, member.Amount);
}
public void Credit_WhenUnableToUpdatePotUser_ShouldLogError()
{
var pot = ModelTestHelper.CreatePot(2, 1);
var potUser = ModelTestHelper.CreatePotUser(1, pot.Id);
const string error = "Unable to update pot user";
var errors = new List <string> {
error
};
_mockPotUserRepo.Setup(s => s.GetPotUser(pot.Id, 1)).Returns(potUser);
_mockPotUserRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockPotUserRepo.Setup(s => s.UpdatePotUser(potUser)).Callback
(
() =>
{
_mockPotUserRepo.SetupGet(s => s.HasErrors).Returns(true);
_mockPotUserRepo.SetupGet(s => s.Errors).Returns(errors);
}
);
CreateServices();
_potServices.Credit(pot, 1, 100);
Assert.IsTrue(_potServices.HasErrors);
Assert.IsTrue(_potServices.Errors.Contains(error));
}
public void Equals_ShouldReturnCorrectValue(int firstUserId, int firstPotId, int secondUserId, int secondPotId, bool expected)
{
var firstPotUser = ModelTestHelper.CreatePotUser(firstUserId, firstPotId);
var secondPotUser = ModelTestHelper.CreatePotUser(secondUserId, secondPotId);
Assert.AreEqual(expected, firstPotUser.Equals(secondPotUser));
}
public void RequestFriendship_WhenUnableToSaveOtherFriendship_ShouldLogError()
{
var friendshp = ModelTestHelper.CreateFriendship(1, "aFriend");
var friend = ModelTestHelper.CreateUser(2, "aFriend");
var otherFriendship = ModelTestHelper.CreateFriendship(2, "me");
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(new List <string>(0));
_mockUserRepo.SetupGet(g => g.HasErrors).Returns(false);
_mockUserRepo.SetupGet(g => g.Errors).Returns(new List <string>(0));
_mockUserRepo.SetupGet(g => g.Errors).Returns(new List <string>(0));
_mockUserRepo.Setup(s => s.GetUserInfo(It.IsAny <string>())).Returns(() => friend);
_mockFriendshipRepo.Setup(s => s.GetFriendship(2, "me")).Returns(() => otherFriendship);
_mockFriendshipRepo.Setup(s => s.SaveFriendship(otherFriendship)).Callback
(
() =>
{
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(true);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(new List <string> {
"Unable to save other friendship"
});
}
);
CreateFriendshipServices();
_friendshipServices.RequestFriendship(friendshp, "me");
Assert.IsTrue(_friendshipServices.HasErrors);
Assert.IsTrue(_friendshipServices.Errors.Contains("Unable to save other friendship"));
}
public void DenyFriend_WhenUnableToFindOtherFriendship_ShouldLogError()
{
var friendshp = ModelTestHelper.CreateFriendship(1, "aFriend");
var friend = ModelTestHelper.CreateUser(2, "aFriend");
const string error = "Unable to delete current friendship";
var errors = new List <string> {
error
};
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(new List <string>(0));
_mockUserRepo.SetupGet(g => g.HasErrors).Returns(false);
_mockUserRepo.SetupGet(g => g.Errors).Returns(new List <string>(0));
_mockUserRepo.Setup(s => s.GetUserInfo(It.IsAny <string>())).Returns(() => friend);
_mockFriendshipRepo.Setup(s => s.GetFriendship(2, "me")).Callback
(
() =>
{
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(true);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(errors);
}
);
CreateFriendshipServices();
_friendshipServices.DenyFriendship(friendshp, "me");
Assert.IsTrue(_friendshipServices.HasErrors);
Assert.IsTrue(_friendshipServices.Errors.Contains(error));
}
public void Equals_ShouldReturnCorrectValue(int firstId, int secondId,
bool expected)
{
var firstPot = ModelTestHelper.CreatePot(firstId, 1);
var secondPot = ModelTestHelper.CreatePot(secondId, 2);
Assert.AreEqual(expected, firstPot.Equals(secondPot));
}
public void Equals_ShouldReturnCorrectValue(int firstId, string firstTripName, int secondId, string secondTripName,
bool expected)
{
var firstUserTrip = ModelTestHelper.CreateUserTrip(firstId, firstTripName);
var secondUserTrip = ModelTestHelper.CreateUserTrip(secondId, secondTripName);
Assert.AreEqual(expected, firstUserTrip.Equals(secondUserTrip));
}
public void Equals_ShouldReturnCorrectValue(int firstId, string firstPseudo, int secondId, string secondPseudo,
bool expected)
{
var firstPtp = ModelTestHelper.CreateTripParticipant(firstId, firstPseudo);
var secondPtp = ModelTestHelper.CreateTripParticipant(secondId, secondPseudo);
Assert.AreEqual(expected, firstPtp.Equals(secondPtp));
}
public void Equals_ShouldReturnCorrectValue(int firstId, int secondId,
bool expected)
{
var firstTrip = ModelTestHelper.CreateTrip(firstId, "TripName");
var secondTrip = ModelTestHelper.CreateTrip(secondId, "SecondTrip");
Assert.AreEqual(expected, firstTrip.Equals(secondTrip));
}
public void Equals_ShouldReturnCorrectValue(int firstId, string firstFriendName, int secondId, string secondFriendName,
bool expected)
{
var firstFriend = ModelTestHelper.CreateFriendship(firstId, firstFriendName);
var secondFriend = ModelTestHelper.CreateFriendship(secondId, secondFriendName);
Assert.AreEqual(expected, firstFriend.Equals(secondFriend));
}
public void Clone_ShoulDuplicateValues()
{
var pot = ModelTestHelper.CreatePot(1, 1, "cloneOrga", name: "ClonePot");
pot.AddParticipant(ModelTestHelper.CreatePotUser(1, 1));
pot.AddParticipant(ModelTestHelper.CreatePotUser(2, 1));
TestClone(pot);
}
public void CopyConstructor_ShouldCopyValues()
{
var user = ModelTestHelper.CreateUser(1, "CopyPseudo");
var copy = new User(user);
Assert.IsFalse(ReferenceEquals(user, copy));
Assert.IsTrue(ReferenceEquals(user.Friends, copy.Friends));
}
public void CreateUser_WhenValid_ShouldCommit()
{
var user = ModelTestHelper.CreateUser(-1, "CommitUser");
var service = new UserServices();
service.CreateUser(user);
Assert.IsNotNull(service.GetUserInfo(user.Pseudo));
}
