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