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 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 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 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 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 Clone_ShouldDuplicateEveryValue()
{
var friendship = ModelTestHelper.CreateFriendship(3, "forClone", new DateTime(2017, 03, 05),
true, false);
TestClone(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 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 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 RequestFriendship_WhenException_ShouldLogError()
{
var friendship = ModelTestHelper.CreateFriendship(1, "aFriend");
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Throws(new Exception("Exception for Test"));
CreateFriendshipServices();
_friendshipServices.RequestFriendship(friendship, "toto");
Assert.IsTrue(_friendshipServices.HasErrors);
Assert.IsTrue(_friendshipServices.Errors.Contains("Exception for Test"));
}
public void DeleteUser_WhenException_ShouldLogError()
{
var user = ModelTestHelper.CreateUser(1, "first");
user.AddFriend(ModelTestHelper.CreateFriendship(user.Id, "aFriend"));
_mockUserRepo.SetupGet(s => s.HasErrors).Throws(new Exception("Exception For Test"));
CreateUserServices();
_userServices.DeleteUser(user);
Assert.IsTrue(_userServices.HasErrors);
Assert.IsTrue(_userServices.Errors.Contains("Exception For Test"));
}
public void RequestFriendship_WhenException_ShouldRollback()
{
var friendship = ModelTestHelper.CreateFriendship(1, "aFriend");
var friendshipRepo = new FriendshipRepository();
var mock = new Mock <IUserRepository>();
mock.SetupGet(s => s.HasErrors).Throws(new Exception("For Rollback"));
var service = new FriendshipServices(mock.Object, friendshipRepo);
service.RequestFriendship(friendship, "aFriend");
Assert.IsNull(friendshipRepo.GetFriendship(friendship.UserId, friendship.FriendName));
}
public void GetFriendship_ShouldReturnFriendship()
{
var mock = CreateMock();
var friendship = ModelTestHelper.CreateFriendship(1, "toto");
mock.Setup(s => s.GetEntity(It.IsAny <FriendshipKey>())).Returns(friendship);
var repo = CreateRepository(mock.Object);
var dbfriendship = repo.GetFriendship(1, "toto");
Assert.IsFalse(repo.HasErrors);
Assert.IsNotNull(friendship);
}
public void Clone_ShoulDuplicateValues()
{
var user = ModelTestHelper.CreateUser(1, "Clone", mail: "CloneEmail", role: Role.Common,
phoneNumber: "ClonePhoneNumber");
user.CenterOfInterests.Add("ACenterOfInterest");
user.CenterOfInterests.Add("Tennis");
user.AddFriend(ModelTestHelper.CreateFriendship(1, "AFriend"));
user.AddFriend(ModelTestHelper.CreateFriendship(1, "TOTO"));
user.AddTrip(ModelTestHelper.CreateUserTrip(1, "ATrip"));
user.AddTrip(ModelTestHelper.CreateUserTrip(1, "SecondTrip"));
TestClone(user);
}
public void GetFriendship_WhenValid_ShouldReturnFriendship()
{
var friendship = ModelTestHelper.CreateFriendship(1, "aFriend");
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(new List <string>(0));
_mockFriendshipRepo.Setup(s => s.GetFriendship(1, "aFriend")).Returns(friendship);
CreateFriendshipServices();
var dbFriendship = _friendshipServices.GetFriendship(1, "aFriend");
Assert.IsFalse(_friendshipServices.HasErrors);
Assert.IsNotNull(dbFriendship);
}
public void RequestFriendship_WhenErrorDuringSave_ShouldRollback()
{
var friendship = ModelTestHelper.CreateFriendship(1, "aFriend");
var friendshipRepo = new FriendshipRepository();
var mock = new Mock <IUserRepository>();
mock.SetupGet(s => s.HasErrors).Returns(true);
mock.Setup(s => s.GetUserInfo(It.IsAny <string>())).Returns(() => null);
var service = new FriendshipServices(mock.Object, friendshipRepo);
service.RequestFriendship(friendship, "aFriend");
Assert.IsNull(friendshipRepo.GetFriendship(friendship.UserId, friendship.FriendName));
}
public void GetUserFriendship_WhenValid_ShouldNotLogError()
{
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(new List <string>());
_mockFriendshipRepo.Setup(s => s.GetUserFriendships(1))
.Returns(new List <Friendship> {
ModelTestHelper.CreateFriendship(1, "one"), ModelTestHelper.CreateFriendship(1, "two")
});
CreateUserServices();
var list = _userServices.GetUserFriendships(1);
Assert.IsFalse(_userServices.HasErrors);
Assert.AreEqual(2, list.Count());
}
public void GetRequestedFrienships_ShouldReturnRightRecords()
{
var firstFriend = ModelTestHelper.CreateFriendship(1, "toto", isRequested: true, isWaiting: true);
var secondFriend = ModelTestHelper.CreateFriendship(1, "tutu", isRequested: false, isWaiting: true);
var thirdFriend = ModelTestHelper.CreateFriendship(1, "Friend", isRequested: true, isWaiting: false);
Assert.IsTrue(_importExport.Save(firstFriend));
Assert.IsTrue(_importExport.Save(secondFriend));
Assert.IsTrue(_importExport.Save(thirdFriend));
var list = _importExport.GetRequestedFriendships(1);
Assert.AreEqual(1, list.Count());
Assert.IsTrue(list.Any(f => f.FriendName == "toto"));
}
public void RequestFriendship_WhenFriendAccountIsNull_ShouldLogError()
{
var friendshp = ModelTestHelper.CreateFriendship(1, "AccountNull");
_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(() => null);
CreateFriendshipServices();
_friendshipServices.RequestFriendship(friendshp, "AccountNull");
Assert.IsTrue(_friendshipServices.HasErrors);
Assert.IsTrue(_friendshipServices.Errors.Contains("Unable to find friend's account"));
}
public void RequestFriendship_WhenUnableToDeleteFriendship_ShouldLogError()
{
const string error = "Unable to save current friendship";
var errors = new List <string> {
error
};
var friendshp = ModelTestHelper.CreateFriendship(1, "saveFailed");
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(true);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(errors);
CreateFriendshipServices();
_friendshipServices.RequestFriendship(friendshp, "aSaveFailed");
Assert.IsTrue(_friendshipServices.HasErrors);
Assert.IsTrue(_friendshipServices.Errors.Contains(error));
}
public void Delete_WhenErrorDuringDelete_ShouldRollBack()
{
var userRepo = new UserRepository();
var friendshipRepo = new FriendshipRepository();
var tripRepo = new UserTripRepository();
var user = ModelTestHelper.CreateUser(1, "DeleteUser");
var pwd = user.Password;
userRepo.SaveUser(user);
Assert.IsFalse(userRepo.HasErrors);
var secondUser = ModelTestHelper.CreateUser(2, "AFriend", "AFriendMail");
userRepo.SaveUser(secondUser);
Assert.IsFalse(userRepo.HasErrors);
var friendship = ModelTestHelper.CreateFriendship(user.Id, secondUser.Pseudo);
var otherFriendship = ModelTestHelper.CreateFriendship(secondUser.Id, user.Pseudo);
friendshipRepo.SaveFriendship(friendship);
friendshipRepo.SaveFriendship(otherFriendship);
Assert.IsFalse(friendshipRepo.HasErrors);
user.AddFriend(friendship);
secondUser.AddFriend(otherFriendship);
var trip = ModelTestHelper.CreateUserTrip(user.Id, "ATrip");
tripRepo.SaveUserTrip(trip);
Assert.IsFalse(tripRepo.HasErrors);
user.AddTrip(trip);
var mock = new Mock <IUserTripRepository>();
mock.Setup(s => s.DeleteUserTrip(trip)).Callback(() => tripRepo.DeleteUserTrip(trip));
mock.SetupGet(s => s.HasErrors).Returns(true);
var service = new UserServices(new UserRepository(), mock.Object, new FriendshipRepository());
service.DeleteUser(user);
service = new UserServices();
var dbUser = service.LoginByPseudo(user.Pseudo, pwd);
Assert.IsNotNull(dbUser);
Assert.AreEqual(1, dbUser.Friends.Count());
Assert.AreEqual(1, dbUser.Trips.Count());
Assert.AreEqual(1, service.GetUserTrips(user.Id).Count());
Assert.AreEqual(1, service.GetUserFriendships(user.Id).Count());
Assert.AreEqual(1, service.GetUserFriendships(secondUser.Id).Count(f => f.FriendName == user.Pseudo));
}
public void DenyFriendship_WhenOtherFriendshipIsNull_ShouldLogError()
{
var friendshp = ModelTestHelper.CreateFriendship(1, "aFriend");
var friend = ModelTestHelper.CreateUser(2, "aFriend");
_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")).Returns(() => null);
CreateFriendshipServices();
_friendshipServices.DenyFriendship(friendshp, "me");
Assert.IsTrue(_friendshipServices.HasErrors);
Assert.IsTrue(_friendshipServices.Errors.Contains("Unable to find friend's friendship"));
}
public void GetUserFriendships_ShouldReturnRecordsForUser()
{
var firstFriend = ModelTestHelper.CreateFriendship(1, "toto");
var secondFriend = ModelTestHelper.CreateFriendship(2, "tutu");
var thirdFriend = ModelTestHelper.CreateFriendship(1, "Friend");
Assert.IsTrue(_importExport.Save(firstFriend));
Assert.IsTrue(_importExport.Save(secondFriend));
Assert.IsTrue(_importExport.Save(thirdFriend));
var list = _importExport.GetUserFriendships(1);
Assert.AreEqual(2, list.Count());
Assert.IsTrue(list.Any(f => f.FriendName == "toto"));
Assert.IsTrue(list.Any(f => f.FriendName == "Friend"));
Assert.IsFalse(list.Any(f => f.UserId == 2));
}
public void RequestFriendship_ShouldNotFail()
{
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);
CreateFriendshipServices();
_friendshipServices.RequestFriendship(friendshp, "me");
Assert.IsFalse(_friendshipServices.HasErrors);
}
public void RequestFriendship_WhenUnableToFindOtherFriendAccount_ShouldLogError()
{
const string error = "Unable to find friend account";
var errors = new List <string> {
error
};
var friendshp = ModelTestHelper.CreateFriendship(1, "WrongOtherUser");
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(new List <string>(0));
_mockUserRepo.SetupGet(g => g.HasErrors).Returns(true);
_mockUserRepo.SetupGet(g => g.Errors).Returns(errors);
CreateFriendshipServices();
_friendshipServices.RequestFriendship(friendshp, "wrongUser");
Assert.IsTrue(_friendshipServices.HasErrors);
Assert.IsTrue(_friendshipServices.Errors.Contains(error));
}
public void DeleteUser_WhenUserRepoHasErrorFindingFriends_ShouldLogError()
{
var errors = new List <string> {
"repo in error"
};
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.Errors).Returns(errors);
_mockUserRepo.SetupGet(s => s.HasErrors).Returns(true);
_mockFriendshipRepo.Setup(s => s.Errors).Returns(new List <string>());
CreateUserServices();
_userServices.DeleteUser(user);
Assert.IsTrue(_userServices.HasErrors);
Assert.IsTrue(_userServices.Errors.Contains("repo in error"));
}
public void GetAllEntities_ShouldReturnAllRecords()
{
var firstFriend = ModelTestHelper.CreateFriendship(1, "toto");
var secondFriend = ModelTestHelper.CreateFriendship(2, "tutu");
var thirdFriend = ModelTestHelper.CreateFriendship(1, "Friend");
Assert.IsTrue(_importExport.Save(firstFriend));
Assert.IsTrue(_importExport.Save(secondFriend));
Assert.IsTrue(_importExport.Save(thirdFriend));
var list = _importExport.GetAllEntities();
Assert.AreEqual(3, list.Count());
Assert.IsTrue(list.Any(f => f.FriendName == "toto"));
Assert.IsTrue(list.Any(f => f.FriendName == "tutu"));
Assert.IsTrue(list.Any(f => f.FriendName == "Friend"));
Assert.IsTrue(list.Any(f => f.UserId == 2));
Assert.IsTrue(list.Any(f => f.UserId == 1));
}
public void GetWaitingFriendships_ShouldReturnValidList()
{
var list = new List <Friendship>
{
ModelTestHelper.CreateFriendship(3, "Afriend"),
ModelTestHelper.CreateFriendship(3, "SecondFriend")
};
var mock = CreateMock();
mock.Setup(s => s.GetWaitingFriendships(3)).Returns(list);
var repo = CreateRepository(mock.Object);
var dbList = repo.GetWaitingFriendships(3);
Assert.IsFalse(repo.HasErrors);
Assert.AreEqual(2, dbList.Count());
Assert.IsTrue(dbList.Any(f => f.FriendName == "Afriend"));
Assert.IsTrue(dbList.Any(f => f.FriendName == "SecondFriend"));
}
public void DeleteUser_WhenOtherFriendshipIsNull_ShouldLogError()
{
var errors = new List <string> {
"error when searching for 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(true);
_mockFriendshipRepo.Setup(s => s.GetFriendship(2, user.Pseudo)).Returns(() => null);
_mockFriendshipRepo.SetupGet(s => s.Errors).Returns(errors);
CreateUserServices();
_userServices.DeleteUser(user);
Assert.IsTrue(_userServices.HasErrors);
Assert.IsTrue(_userServices.Errors.Contains("error when searching for other friendship"));
}
public void GetWaitingFriendships_ShouldReturnValidRecord()
{
_mockFriendshipRepo.Setup(s => s.GetWaitingFriendships(1)).Returns
(
new List <Friendship>
{
ModelTestHelper.CreateFriendship(1, "first"),
ModelTestHelper.CreateFriendship(1, "second")
}
);
_mockFriendshipRepo.SetupGet(s => s.HasErrors).Returns(false);
CreateFriendshipServices();
var list = _friendshipServices.GetWaitingFriendships(1);
Assert.IsFalse(_friendshipServices.HasErrors);
Assert.AreEqual(2, list.Count());
Assert.IsTrue(list.Any(f => f.FriendName == "first"));
Assert.IsTrue(list.Any(f => f.FriendName == "second"));
}