public void ReturnCollectionWithFounModels_WhenPassedValueMatchesName()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var user = new User();
string firstname = "testUser";
var individual = new Individual();
individual.User = user;
individual.FirstName = firstname;
individual.LastName = "LastName";
var data = new List <Individual>();
data.Add(individual);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetIndividualsByNameOrUsername(firstname);
// Assert
Assert.AreEqual(1, result.Count());
}
public void ReturnEmptyCollection_WhenPassedValueIsNull()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var user = new User();
string userId = "testUserId";
user.Id = userId;
var individual = new Individual();
individual.User = user;
var data = new List <Individual>();
data.Add(individual);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetIndividualsByNameOrUsername(null);
// Assert
Assert.IsEmpty(result);
}
public void CallWrapperAll_WhenCalled()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.SetupGet(x => x.All).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var individual1 = new Individual();
var firstName1 = "first name";
individual1.FirstName = firstName1;
var individual2 = new Individual();
var firstName2 = "secont name";
individual2.FirstName = firstName2;
var data = new List <Individual>();
data.Add(individual1);
data.Add(individual2);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetAll();
// Assert
mockedEfWrappert.Verify(x => x.All, Times.Once);
}
public void ReturnNull_WhenThereIsNotAModelWithThePassedUser()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
string userId = "testUserId";
var user = new User();
user.Id = userId;
var individual = new Individual();
individual.User = user;
var data = new List <Individual>();
data.Add(individual);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetByUser("otherTestUserId");
// Assert
Assert.IsNull(result);
}
public void ReturnCollection_WhenUsernameMatch()
{
// Arrange
var organization = new Organization();
var user = new User();
var username = "******";
user.UserName = username;
var individual = new Individual();
individual.User = user;
individual.Following.Add(organization);
var data = new List <Individual>();
data.Add(individual);
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.All).Returns(data.AsQueryable());
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetFollowingOrganization(username);
// Assert
Assert.AreEqual(1, result.Count());
}
public void CallUpdateMethod_WhenParamsMatch()
{
// Arrange
var user = new User();
var username = "******";
user.UserName = username;
var individual = new Individual();
individual.User = user;
var data = new List <Individual>();
data.Add(individual);
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
mockedEfWrappert.Setup(x => x.Update(It.IsAny <Individual>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.CreateEvent(new Event(), username);
// Assert
mockedEfWrappert.Verify(x => x.Update(It.IsAny <Individual>()), Times.Once);
}
public void ReturnEmptyCollection_WhenPassedValueDoesntMatch()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var user = new User();
string firstname = "testUser";
var individual = new Individual();
individual.User = user;
individual.FirstName = firstname;
individual.LastName = "LastName";
var data = new List <Individual>();
data.Add(individual);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetIndividualsByNameOrUsername("otherTestName");
// Assert
Assert.IsEmpty(result);
}
public void ReturnCollectionWithAllModels_WhenCalled()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var individual1 = new Individual();
var firstName1 = "first name";
individual1.FirstName = firstName1;
var individual2 = new Individual();
var firstName2 = "secont name";
individual2.FirstName = firstName2;
var data = new List <Individual>();
data.Add(individual1);
data.Add(individual2);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetAll();
// Assert
Assert.AreEqual(2, result.Count());
}
public void IndividualService_Add_Throws_On_Null_Individual()
{
//Arrange
_service = new IndividualService(_mockUnitOfWork.Object);
//Assert
Assert.Throws<ArgumentNullException>(() => _service.Add(null));
}
public void NotThrowException_WhenUserIsNull()
{
// Arange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act & Assert
Assert.DoesNotThrow(() => service.GetFriendsRequests(null));
}
/// <summary>
/// Creates a new NinthBrain object using provided apiKey and accessToken parameters
/// </summary>
/// <param name="config">Configuration</param>
public NinthBrainSuiteService(Configuration config)
{
configuration = config;
individualService = new IndividualService(configuration, this);
certificationService = new CertificationService(configuration, this);
individualCertificationService = new IndividualCertificationService(configuration, this);
departmentService = new DepartmentService(configuration, this);
jobTitleService = new JobTitleService(configuration, this);
localeService = new LocaleService(configuration, this);
workShiftService = new WorkShiftService(configuration, this);
individualCourseService = new IndividualCourseService(configuration, this);
}
public IndividualServiceTests()
{
_mockConnection
.Setup(_ => _.Client())
.Returns(_mockClient.Object);
_individualWeightings = new List <IIndividualWeighting>
{
_mockIndividualWeighting.Object
};
_service = new IndividualService(_mockConnection.Object, _individualWeightings, _mockPropertyService.Object, _mockLogger.Object);
}
public void ReturnStatusNone_WhenUserIsNull()
{
// Arange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetStatus(null, userToCheckId);
// Assert
Assert.AreEqual(IndividualStatus.None, result);
}
public void ReturnEmptyCollection_WhenUsernameIsNull()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetUpcomingEvents(null);
// Assert
Assert.IsEmpty(result);
}
public void NotCallAllMethod_WhenPassedEventIsNull()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.All).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.CreateEvent(null, "testUserId");
// Assert
mockedEfWrappert.Verify(x => x.All, Times.Never);
}
public void NotCallGetByIdMethod_WhenPassedUsernameIsNull()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.GetById(It.IsAny <Guid>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.FollowPlace(null, new Organization());
// Assert
mockedEfWrappert.Verify(x => x.GetById(It.IsAny <Guid>()), Times.Never);
}
public void NotCallGetByIdMethod_WhenPassedIdIsNull()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.GetById(It.IsAny <Guid>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.RemoveFriendship("testUserId", null);
// Assert
mockedEfWrappert.Verify(x => x.GetById(It.IsAny <Guid>()), Times.Never);
}
public void NotCallWrapperUpdateMethod_WhanPassedVauleIsNull()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.Update(It.IsAny <Individual>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.Update(null);
// Assert
mockedEfWrappert.Verify(x => x.Update(It.IsAny <Individual>()), Times.Never);
}
public void NotCallUpdateMethod_WhenUsernameDoesntMatch()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.GetById(It.IsAny <Guid>())).Returns((Individual)null);
mockedEfWrappert.Setup(x => x.Update(It.IsAny <Individual>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.FollowPlace(Guid.NewGuid(), new Organization());
// Assert
mockedEfWrappert.Verify(x => x.Update(It.IsAny <Individual>()), Times.Never);
}
public void ReturnNull_WhenThereIsNotAModelWithThePassedId()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
Guid?individualId = Guid.NewGuid();
mockedEfWrappert.Setup(m => m.GetById(individualId.Value)).Returns((Individual)null);
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetById(individualId);
// Assert
Assert.IsNull(result);
}
public void ReturnEmptyCollection_WhenThereIsNotAModelWithThePassedUser()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var data = Data();
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetFriendsRequests("otherTestUser");
// Assert
Assert.AreEqual(0, result.Count());
}
public void CallUpdateMethod_WhenValidParametersArePassed()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(new Individual());
mockedEfWrappert.Setup(x => x.Update(It.IsAny <Individual>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.FollowPlace(Guid.NewGuid(), new Organization());
// Assert
mockedEfWrappert.Verify(x => x.Update(It.IsAny <Individual>()), Times.Once);
}
public void ReturnEmptyCollection_WhenNoEntities()
{
// Arrange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var data = new List <Individual>();
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetAll();
// Assert
Assert.IsEmpty(result);
}
public void ReturnStatusCurrent_WhenUserToCheckIsCurrent()
{
// Arange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var data = Data();
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetStatus(username, individualId);
// Assert
Assert.AreEqual(IndividualStatus.IsCurrent, result);
}
public void ReturnEmptyCollection_WhenUsernameDoesntMatch()
{
// Arrange
var data = new List <Individual>();
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.All).Returns(data.AsQueryable());
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetFollowingOrganization("testUser");
// Assert
Assert.IsEmpty(result);
}
public void ReturnCorrectCollection_WhenUsernameMatch()
{
// Arrange
var data = new List <Individual>();
var currentDate = new DateTime(2017, 1, 1, 00, 00, 00);
var event1 = new Event();
event1.Begins = currentDate.AddDays(1);
event1.Ends = currentDate.AddDays(2);
var event2 = new Event();
event2.Begins = currentDate.AddDays(-1);
event2.Ends = currentDate.AddDays(1);
var user = new User();
var username = "******";
user.UserName = username;
var individual = new Individual();
individual.User = user;
individual.Events.Add(event1);
individual.Events.Add(event2);
data.Add(individual);
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.All).Returns(data.AsQueryable());
var mockedDbContext = new Mock <IUnitOfWork>();
var mockedDateTime = new Mock <DateTimeProvider>();
mockedDateTime.SetupGet(x => x.UtcNow).Returns(currentDate);
DateTimeProvider.Current = mockedDateTime.Object;
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetCurrentEvents(username);
DateTimeProvider.ResetToDefault();
// Assert
Assert.AreEqual(1, result.Count());
Assert.AreSame(event2, result.First());
}
public void NotCallUpdateMethod_WhenParamsDoesntMatch()
{
// Arrange
var data = new List <Individual>();
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
mockedEfWrappert.Setup(x => x.Update(It.IsAny <Individual>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.CreateEvent(new Event(), "testUserId");
// Assert
mockedEfWrappert.Verify(x => x.Update(It.IsAny <Individual>()), Times.Never);
}
public void IndividualService_Add_Calls_Repository_Add_Method_With_The_Same_Individual_Object_It_Recieved()
{
// Create test data
var newIndividual = new Individual
{
FirstName = "Foo",
LastName = "Bar"
};
//Create Mock
var mockRepository = new Mock<IRepository<Individual>>();
_mockUnitOfWork.Setup(d => d.GetRepository<Individual>()).Returns(mockRepository.Object);
//Arrange
_service = new IndividualService(_mockUnitOfWork.Object);
//Act
_service.Add(newIndividual);
//Assert
mockRepository.Verify(r => r.Add(newIndividual));
}
public void ReturnStatusIsFriend_WhenUserToCheckIsFriend()
{
// Arange
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
var mockedDbContext = new Mock <IUnitOfWork>();
var data = Data();
var friend = new Individual();
friend.Id = userToCheckId;
data.First().Friends.Add(friend);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
var result = service.GetStatus(username, userToCheckId);
data.First().Friends.Remove(friend);
// Assert
Assert.AreEqual(IndividualStatus.IsFriend, result);
}
public void CallUpdateMethod_WhenParamsMatch()
{
// Arrange
var username = "******";
var user = new User();
user.UserName = username;
var individual = new Individual();
individual.User = user;
var id = Guid.NewGuid();
var friend = new Individual();
friend.Id = id;
var data = new List <Individual>();
data.Add(individual);
data.Add(friend);
var mockedEfWrappert = new Mock <IEfDbSetWrapper <Individual> >();
mockedEfWrappert.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(friend);
mockedEfWrappert.SetupGet(m => m.All).Returns(data.AsQueryable());
mockedEfWrappert.Setup(x => x.Update(It.IsAny <Individual>())).Verifiable();
var mockedDbContext = new Mock <IUnitOfWork>();
var service = new IndividualService(mockedEfWrappert.Object, mockedDbContext.Object);
// Act
service.RemoveFriendship(username, id);
// Assert
mockedEfWrappert.Verify(x => x.Update(It.IsAny <Individual>()), Times.Exactly(2));
}
public void IndividualService_Add_Calls_UnitOfWork_Commit_Method()
{
// Create test data
var newIndividual = new Individual
{
FirstName = "Foo",
LastName = "Bar"
};
//Create Mock
var mockRepository = new Mock<IRepository<Individual>>();
_mockUnitOfWork.Setup(d => d.GetRepository<Individual>()).Returns(mockRepository.Object);
//Arrange
_service = new IndividualService(_mockUnitOfWork.Object);
//Act
_service.Add(newIndividual);
//Assert
_mockUnitOfWork.Verify(db => db.Commit());
}
public void IndividualService_Get_Throws_On_Negative_Id()
{
//Arrange
_service = new IndividualService(_mockUnitOfWork.Object);
//Assert
Assert.Throws<IndexOutOfRangeException>(() => _service.Get(-1, It.IsAny<int>()));
}
public void IndividualService_Get_Returns_Null_On_InValid_Id()
{
//Arrange
var mockRepository = new Mock<IRepository<Individual>>();
mockRepository.Setup(r => r.Get(It.IsAny<int>())).Returns(GetIndividuals(TestConstants.PAGE_TotalCount));
_mockUnitOfWork.Setup(u => u.GetRepository<Individual>()).Returns(mockRepository.Object);
_service = new IndividualService(_mockUnitOfWork.Object);
const int id = TestConstants.ID_NotFound;
//Act
var individual = _service.Get(id, It.IsAny<int>());
//Assert
Assert.IsNull(individual);
}
public void IndividualService_Get_ByPage_Overload_Calls_Repository_Get()
{
//Arrange
var mockRepository = new Mock<IRepository<Individual>>();
_mockUnitOfWork.Setup(u => u.GetRepository<Individual>()).Returns(mockRepository.Object);
_service = new IndividualService(_mockUnitOfWork.Object);
const int treeId = TestConstants.TREE_Id;
//Act
_service.Get(treeId, t => true, 0, TestConstants.PAGE_RecordCount);
//Assert
mockRepository.Verify(r => r.Get(It.IsAny<int>()));
}
public void IndividualService_Get_ByPage_Overload_Returns_PagedList_Of_Individuals()
{
//Arrange
var mockRepository = new Mock<IRepository<Individual>>();
mockRepository.Setup(r => r.Get(It.IsAny<int>())).Returns(GetIndividuals(TestConstants.PAGE_TotalCount));
_mockUnitOfWork.Setup(u => u.GetRepository<Individual>()).Returns(mockRepository.Object);
_service = new IndividualService(_mockUnitOfWork.Object);
const int treeId = TestConstants.TREE_Id;
//Act
var individuals = _service.Get(treeId, t => true, 0, TestConstants.PAGE_RecordCount);
//Assert
Assert.IsInstanceOf<IPagedList<Individual>>(individuals);
Assert.AreEqual(TestConstants.PAGE_TotalCount, individuals.TotalCount);
Assert.AreEqual(TestConstants.PAGE_RecordCount, individuals.PageSize);
}
public void IndividualService_Get_Calls_Repository_Get()
{
//Arrange
var mockRepository = new Mock<IRepository<Individual>>();
_mockUnitOfWork.Setup(u => u.GetRepository<Individual>()).Returns(mockRepository.Object);
_service = new IndividualService(_mockUnitOfWork.Object);
const int id = TestConstants.ID_Exists;
//Act
_service.Get(id, It.IsAny<int>());
//Assert
mockRepository.Verify(r => r.Get(It.IsAny<int>()));
}
public void IndividualService_Get_ByPage_Overload_Throws_On_Negative_TreeId()
{
//Arrange
_service = new IndividualService(_mockUnitOfWork.Object);
//Assert
Assert.Throws<IndexOutOfRangeException>(() => _service.Get(-1, t => true, 0, TestConstants.PAGE_RecordCount));
}
public void IndividualService_Get_Overload_Throws_On_Negative_TreeId()
{
//Arrange
_service = new IndividualService(_mockUnitOfWork.Object);
//Assert
Assert.Throws<IndexOutOfRangeException>(() => _service.Get(-1));
}
