public When_MatchingServiceProviderOpportunityReport_Is_Called_For_Multiple_Opportunity_And_Single_Provider_Venue()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
_postcodeLookupBuilder = new PostcodeLookupBuilder(_dbContext);
_localEnterprisePartnershipBuilder = new LocalEnterprisePartnershipBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
_provider = _providerBuilder.CreateProvider();
_localEnterprisePartnershipBuilder.CreateLocalEnterprisePartnership();
_postcodeLookupBuilder.CreatePostcodeLookup();
var savedReferralOpportunityItem1 = _opportunityBuilder.CreateReferralOpportunityItem(true, true, _provider.ProviderVenue.Select(pv => pv.Id).ToArray());
var savedReferralOpportunityItem2 = _opportunityBuilder.CreateReferralOpportunityItem(true, true, _provider.ProviderVenue.Select(pv => pv.Id).ToArray());
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
savedReferralOpportunityItem1, savedReferralOpportunityItem2
});
_result = _dbContext.MatchingServiceProviderOpportunityReport.ToList();
}
public When_GetMatchingServiceEmployerReport_Is_Called()
{
var logger = Substitute.For <ILogger>();
var context = new ExecutionContext();
var mockEmployerDbSet = new EmployerBuilder()
.BuildList()
.AsQueryable()
.BuildMockDbSet();
var employerRepository = Substitute.For <IRepository <Domain.Models.Employer> >();
employerRepository.GetManyAsync().Returns(mockEmployerDbSet);
var opportunityRepository = Substitute.For <IOpportunityRepository> ();
_functionLogRepository = Substitute.For <IRepository <FunctionLog> >();
var httpContext = new DefaultHttpContext();
var request = httpContext.Request;
request.Method = HttpMethod.Get.ToString();
var matchingServiceReportFunctions = new Functions.MatchingServiceReport(employerRepository,
opportunityRepository, _functionLogRepository);
_result = matchingServiceReportFunctions.GetMatchingServiceEmployerReportAsync(
request,
context,
logger)
.GetAwaiter().GetResult();
}
public When_MatchingServiceOpportunityReport_Is_Called_For_Pipeline_Opportunity()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
_postcodeLookupBuilder = new PostcodeLookupBuilder(_dbContext);
_localEnterprisePartnershipBuilder = new LocalEnterprisePartnershipBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider = _providerBuilder.CreateProvider();
_localEnterprisePartnershipBuilder.CreateLocalEnterprisePartnership();
_postcodeLookupBuilder.CreatePostcodeLookup();
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, false, provider.ProviderVenue.First().Id);
_savedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(true, false);
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem, _savedProvisionGapOpportunityItem
});
_result = _dbContext.MatchingServiceOpportunityReport.ToList();
}
public async Task GetAllContractsByDay_ShouldReturnAllContractsByDayFromRepository()
{
// Arrange
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var workshifts = new List <Workshift>
{
new WorkshiftBuilder().WithStartDateTime(DateTime.Now).Build(),
};
var workschedule = new WorkscheduleBuilder().WithId(1).WithWorkshifts(workshifts).Build();
var contracts = new List <Contract>
{
new ContractBuilder().WithId(1).WithPerson(person).WithEmployer(employer).WithWorkschedule(workschedule).Build(),
};
_contractRepositoryMock.Setup(c => c.GetContractsByEmployerId(It.IsAny <long>())).ReturnsAsync(contracts);
// Act
var result = await _contractService.GetAllContractsByDay(1, DateTime.Now);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(contracts));
_contractRepositoryMock.Verify(c => c.GetContractsByEmployerId(1), Times.Once);
}
public When_MatchingServiceOpportunityReport_Is_Called_For_Saved_OpportunityOpportunities()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider1 = _providerBuilder.CreateProvider();
var provider2 = _providerBuilder.CreateProvider();
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, true, provider1.ProviderVenue.First().Id);
_savedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(true, true);
_unsavedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(false, false, provider2.ProviderVenue.First().Id);
_unsavedProvisionGapOpportunityItem = _opportunityBuilder.CreateProvisionGapOpportunityItem(false, false);
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem, _savedProvisionGapOpportunityItem, _unsavedReferralOpportunityItem, _unsavedProvisionGapOpportunityItem
});
_result = _dbContext.MatchingServiceOpportunityReport.ToList();
}
public void GetAllPersonsByEmployerAndDay_ReturnsAllPersonsByEmployerAndDayFromService()
{
// Arrange
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var contracts = new List <Contract>
{
new ContractBuilder().WithId(1).WithPerson(person).WithEmployer(employer).Build(),
};
var personWorkshiftsViewModels = new List <PersonWorkshiftsViewModel>
{
new PersonWorkshiftsViewModelBuilder().WithId(1).WithName(person.FirstName + " " + person.LastName)
.Build(),
};
_contractServiceMock.Setup(c => c.GetAllContractsByDay(It.IsAny <long>(), It.IsAny <DateTime>()))
.ReturnsAsync(contracts);
_mapperMock.Setup(m => m.Map <List <PersonWorkshiftsViewModel> >(contracts))
.Returns(personWorkshiftsViewModels);
// Act
var okResult = _controller.GetAllPersonsByEmployerAndDay(1, DateTime.MinValue).Result as OkObjectResult;
// Assert
Assert.That(okResult, Is.Not.Null);
Assert.That(okResult.Value, Is.EqualTo(personWorkshiftsViewModels));
_mapperMock.Verify(m => m.Map <List <PersonWorkshiftsViewModel> >(contracts), Times.Once);
}
public void GetAllNotificationsByEmployer_ReturnsAllNotificationsByEmployerFromService()
{
// Assert
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var job = new JobBuilder().WithId(1).Build();
var personViewModel = new PersonViewModelBuilder().WithId(1).Build();
var notifications = new List <Notification>
{
new NotificationBuilder().WithId(1).WithEmployer(employer).WithPerson(person).WithJob(job).Build(),
};
var notificationViewModels = new List <NotificationViewModel>
{
new NotificationViewModelBuilder().WithId(1).WithPerson(personViewModel).WithJob(job).Build(),
};
_notificationServiceMock.Setup(n => n.GetAllNotificationsByEmployerId(It.IsAny <long>()))
.ReturnsAsync(notifications);
_mapperMock.Setup(m => m.Map <List <NotificationViewModel> >(notifications))
.Returns(notificationViewModels);
// Act
var okResult = _controller.GetAllNotificationsByEmployer(1).Result as OkObjectResult;
// Assert
Assert.That(okResult, Is.Not.Null);
Assert.That(okResult.Value, Is.EqualTo(notificationViewModels));
_mapperMock.Verify(m => m.Map <List <NotificationViewModel> >(notifications), Times.Once);
}
public async Task GetContract_ShouldReturnContractFromRepository()
{
// Arrange
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var contract = new ContractBuilder().WithId(1).WithPerson(person).WithEmployer(employer).Build();
_contractRepositoryMock.Setup(c => c.GetContract(It.IsAny <long>())).ReturnsAsync(contract);
// Act
var result = await _contractService.GetContract(contract.Id);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(contract));
}
public async Task AddNotification_ShouldAddNotificationInRepository()
{
// Arrange
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var job = new JobBuilder().WithId(1).Build();
var notification = new NotificationBuilder().WithId(1).WithEmployer(employer).WithPerson(person)
.WithJob(job).Build();
// Act
await _notificationService.AddNotification(notification);
// Assert
_notificationRepositoryMock.Verify(n => n.AddNotification(notification), Times.Once);
_notificationRepositoryMock.Verify(m => m.SaveAsync(), Times.Once());
}
public async Task GetNotification_ShouldReturnNotificatoinFromRepository()
{
// Arrange
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var job = new JobBuilder().WithId(1).Build();
var notification = new NotificationBuilder().WithId(1).WithEmployer(employer).WithPerson(person)
.WithJob(job).Build();
_notificationRepositoryMock.Setup(n => n.GetNotification(It.IsAny <long>())).ReturnsAsync(notification);
// Act
var result = await _notificationService.GetNotification(1);
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.EqualTo(result));
_notificationRepositoryMock.Verify(n => n.GetNotification(1), Times.Once);
}
public void DeleteNotification_ShouldDeleteNotificationInRepository()
{
// Arrange
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var job = new JobBuilder().WithId(1).Build();
var notification = new NotificationBuilder().WithId(1).WithEmployer(employer).WithPerson(person)
.WithJob(job).Build();
_notificationRepositoryMock.Setup(n => n.GetNotification(It.IsAny <long>())).ReturnsAsync(notification);
// Act
_notificationService.DeleteNotification(1);
// Assert
_notificationRepositoryMock.Verify(n => n.GetNotification(1), Times.Once);
_notificationRepositoryMock.Verify(n => n.DeleteNotification(notification), Times.Once);
_notificationRepositoryMock.Verify(m => m.SaveAsync(), Times.Once());
}
public When_MatchingServiceProviderOpportunityReport_Is_Called_For_Single_Provider_Multiple_Venues()
{
_dbContext = new TestConfiguration().GetDbContext();
_opportunityBuilder = new OpportunityBuilder(_dbContext);
_providerBuilder = new ProviderBuilder(_dbContext);
_employerBuilder = new EmployerBuilder(_dbContext);
ClearData();
var employer = _employerBuilder.CreateEmployer(Guid.NewGuid());
var provider = _providerBuilder.CreateProvider(2);
_savedReferralOpportunityItem = _opportunityBuilder.CreateReferralOpportunityItem(true, true, provider.ProviderVenue.Select(pv => pv.Id).ToArray());
_opportunityBuilder.CreateOpportunity(employer.CrmId, new List <OpportunityItem> {
_savedReferralOpportunityItem
});
_result = _dbContext.MatchingServiceProviderOpportunityReport.ToList();
}
public async Task CheckWorkshiftForNotification_ReturnsNotificationIfWorkshiftStateIsPausedStateAndCurrentDateTimeIsSeventyMinutesLargerThanWorkshiftStartDateTime()
{
// Arrange
var startDatetime = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, DateTime.Now.Hour, 00, 00);
var stopDatetime = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, DateTime.Now.Hour, 00, 00);
var workshift = new WorkshiftBuilder().WithId(1).WithTimeblock(DateTime.Now).WithStartDateTime(startDatetime).WithStopDateTime(stopDatetime).WithPausedState().Build();
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var contract = new ContractBuilder().WithId(1).WithPerson(person).WithEmployer(employer).Build();
_contractServiceMock.Setup(c => c.GetContractByWorkshiftId(It.IsAny <long>())).ReturnsAsync(contract);
// Act
var result = await _notificationService.CheckWorkshiftForNotification(workshift);
// Assert
Assert.That(result, Is.Not.Null);
_contractServiceMock.Verify(c => c.GetContractByWorkshiftId(workshift.Id), Times.Once);
}
public async Task GetAllContracts_ShouldReturnAllContractsFromRepository()
{
// Arrange
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var contracts = new List <Contract>
{
new ContractBuilder().WithId(1).WithPerson(person).WithEmployer(employer).Build(),
};
_contractRepositoryMock.Setup(c => c.GetAllContracts()).ReturnsAsync(contracts);
// Act
var result = await _contractService.GetAllContracts();
var enumerableResult = result.ToList();
// Assert
Assert.That(enumerableResult, Is.Not.Null);
Assert.That(enumerableResult, Is.EqualTo(contracts));
_contractRepositoryMock.Verify(c => c.GetAllContracts(), Times.Once);
}
public async Task GetAllNotificationsByEmployerId_ShouldReturnAllNotificationsByEmployerIdFromRepository()
{
var person = new PersonBuilder().WithId(1).Build();
var employer = new EmployerBuilder().WithId(1).Build();
var job = new JobBuilder().WithId(1).Build();
var notifications = new List <Notification>
{
new NotificationBuilder().WithId(1).WithEmployer(employer).WithPerson(person).WithJob(job).Build(),
};
_notificationRepositoryMock.Setup(n => n.GetAllNotificationsByEmployerId(It.IsAny <long>()))
.ReturnsAsync(notifications);
// Act
var result = await _notificationService.GetAllNotificationsByEmployerId(1);
var enumerableResult = result.ToList();
// Assert
Assert.That(enumerableResult, Is.Not.Null);
Assert.That(enumerableResult, Is.EqualTo(result));
_notificationRepositoryMock.Verify(n => n.GetAllNotificationsByEmployerId(1), Times.Once);
}
