public void SetUp()
{
_testApprenticeship = new Apprenticeship
{
FirstName = "John",
LastName = "Smith",
DateOfBirth = new DateTime(1988, 4, 5),
PaymentStatus = PaymentStatus.Active,
StartDate = DateTime.UtcNow.AddMonths(1) // Default start date a month in the future.
};
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipQueryRequest>()))
.ReturnsAsync(new GetApprenticeshipQueryResponse
{
Apprenticeship = _testApprenticeship
});
}
public void Arrange()
{
_mockFeatureToggle = new Mock <IFeatureToggle>();
MockFeatureToggleService.Setup(x => x.Get <Transfers>()).Returns(_mockFeatureToggle.Object);
_sendAsyncResponse = new GetAccountTransferConnectionsResponse
{
TransferConnections = new List <TransferConnection> {
new TransferConnection()
}
};
MockCommitmentMapper.Setup(x => x.MapToTransferConnectionsViewModel(It.IsAny <List <TransferConnection> >()))
.Returns(new List <TransferConnectionViewModel> {
new TransferConnectionViewModel()
});
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetAccountTransferConnectionsRequest>())).ReturnsAsync(_sendAsyncResponse);
}
public async Task ShouldSetStatusTextForApprenticeshipWhenStoped()
{
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipQueryRequest>()))
.ReturnsAsync(new GetApprenticeshipQueryResponse
{
Apprenticeship = new Apprenticeship {
PaymentStatus = PaymentStatus.Withdrawn
}
});
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipUpdateRequest>()))
.ReturnsAsync(new GetApprenticeshipUpdateResponse());
var result = await Orchestrator.GetApprenticeship("hashedAccountId", "hashedApprenticeshipId", "UserId");
result.Data.Status.Should().Be("Stopped");
}
public async Task ThenHasSignedAgreementIsCorrectlyDeterminedForTransfers(EmployerAgreementStatus v1,
EmployerAgreementStatus v2, bool expectHasSigned)
{
//Arrange
_commitmentView.TransferSender = new TransferSender {
Id = 1
};
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetAccountLegalEntitiesRequest>()))
.ReturnsAsync(MockLegalEntitiesResponse(v1, v2));
//Act
var result = await EmployerCommitmentOrchestrator.GetFinishEditingViewModel("ABC123", "XYZ123", "ABC321");
//Assert
Assert.AreEqual(expectHasSigned, result.Data.HasSignedTheAgreement);
}
public async Task Then_The_Providers_Are_Returned_From_Mediator()
{
//Arrange
var fixture = new Fixture();
var getProvidersResponse = fixture.CreateMany <ProviderResponse>().ToList();
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetProvidersQuery>()))
.ReturnsAsync(new GetProvidersQueryResponse
{
Providers = getProvidersResponse
});
//Act
var actual = await Orchestrator.GetProviders();
//Assert
actual.Providers.ShouldBeEquivalentTo(getProvidersResponse);
}
public void ThenInvalidStateExceptionOccursWhenNoViewModelReturned()
{
MockDateTime.Setup(m => m.Now).Returns(new DateTime(1998, 1, 1));
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipQueryRequest>()))
.ReturnsAsync(new GetApprenticeshipQueryResponse
{
Apprenticeship =
new Apprenticeship
{
PaymentStatus = PaymentStatus.Active,
StartDate = new DateTime(1998, 1, 1)
}
});
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipUpdateRequest>()))
.ReturnsAsync(new GetApprenticeshipUpdateResponse());
Assert.ThrowsAsync <InvalidStateException>(() => Orchestrator.GetViewChangesViewModel("hashedAccountId", "hashedApprenticeshipId", "UserId"));
}
public async Task ThenAppropriateCommandIsSentToMediatorOnRejection()
{
//Arrange
var fixture = new Fixture();
var request = fixture.Build <TransferApprovalRequest>()
.With(x => x.TransferApprovalStatus, TransferApprovalStatus.Rejected)
.Create();
//Act
await Orchestrator.SetTransferApprovalStatus(1, 2, 3, request);
//Assert
MockMediator.Verify(
x => x.SendAsync(It.Is <RejectTransferRequestCommand>(p =>
p.TransferSenderId == 1 && p.CommitmentId == 2 && p.TransferRequestId == 3 &&
p.TransferReceiverId == request.TransferReceiverId)), Times.Once);
}
public async Task ShouldCallGetFacetAndMapper()
{
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipsRequest>()))
.ReturnsAsync(new GetApprenticeshipsResponse {
Apprenticeships = new List <Domain.Entities.Apprenticeship>()
});
MockApprenticeshipFilter.Setup(m =>
m.Filter(It.IsAny <IList <Types.Apprenticeship.Apprenticeship> >(), It.IsAny <ApprenticeshipSearchQuery>(), Originator.Employer))
.Returns <IList <Types.Apprenticeship.Apprenticeship>, ApprenticeshipSearchQuery, Originator>((aps, q, o) => new FilterResult(100, aps.ToList(), 1, 25));
var result = await Orchestrator.GetApprenticeships(1L, new ApprenticeshipSearchQuery());
MockMediator.Verify(m => m.SendAsync(It.IsAny <GetApprenticeshipsRequest>()), Times.Once);
MockFacetMapper.Verify(m => m.BuildFacets(It.IsAny <IList <Types.Apprenticeship.Apprenticeship> >(), It.IsAny <ApprenticeshipSearchQuery>(), Originator.Employer), Times.Once);
MockApprenticeshipFilter.Verify(m => m.Filter(It.IsAny <IList <Types.Apprenticeship.Apprenticeship> >(), It.IsAny <ApprenticeshipSearchQuery>(), Originator.Employer), Times.Once);
result.Apprenticeships.Count().Should().Be(0);
}
public async Task ThenCountsShouldBeCorrectWhenEmployerHasTwoCommitments(
int expectedDraftCount, int expectedReadyForReviewCount, int expectedWithProviderCount, int expectedTransferFundedCohortsCount, int expectedRejectedTransferFundedCohortsCount,
long?transferSenderId1, TransferApprovalStatus transferApprovalStatus1,
AgreementStatus agreementStatus1, EditStatus editStatus1, LastAction lastAction1, int apprenticeshipCount1,
long?transferSenderId2, TransferApprovalStatus transferApprovalStatus2,
AgreementStatus agreementStatus2, EditStatus editStatus2, LastAction lastAction2, int apprenticeshipCount2)
{
//Arrange
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentsQuery>()))
.ReturnsAsync(new GetCommitmentsResponse
{
Commitments = new List <CommitmentListItem>
{
new CommitmentListItem
{
TransferSenderId = transferSenderId1,
TransferApprovalStatus = transferApprovalStatus1,
AgreementStatus = agreementStatus1,
EditStatus = editStatus1,
LastAction = lastAction1,
ApprenticeshipCount = apprenticeshipCount1
},
new CommitmentListItem
{
TransferSenderId = transferSenderId2,
TransferApprovalStatus = transferApprovalStatus2,
AgreementStatus = agreementStatus2,
EditStatus = editStatus2,
LastAction = lastAction2,
ApprenticeshipCount = apprenticeshipCount2
}
}
});
//Act
var result = await EmployerCommitmentOrchestrator.GetYourCohorts("ABC123", "ABC321");
//Assert
Assert.AreEqual(expectedDraftCount, result.Data.DraftCount, "Incorrect DraftCount");
Assert.AreEqual(expectedReadyForReviewCount, result.Data.ReadyForReviewCount, "Incorrect ReadyForReviewCount");
Assert.AreEqual(expectedWithProviderCount, result.Data.WithProviderCount, "Incorrect WithProviderCount");
Assert.AreEqual(expectedTransferFundedCohortsCount, result.Data.TransferFundedCohortsCount, "IncorrectTransferFundedCohortsCount");
Assert.AreEqual(expectedRejectedTransferFundedCohortsCount, result.Data.RejectedTransferFundedCohortsCount, "IncorrectRejectedTransferFundedCohortsCount");
}
public async Task AndApprenticeshipIsOverFundingLimitThenACostWarningShouldBeAddedToViewModel()
{
CommitmentView.Apprenticeships = new List <Apprenticeship>
{
new Apprenticeship
{
StartDate = new DateTime(2020, 2, 2),
Cost = 500
}
};
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetTrainingProgrammesQueryRequest>()))
.ReturnsAsync(new GetTrainingProgrammesQueryResponse
{
TrainingProgrammes = new List <TrainingProgramme>
{
new TrainingProgramme
{
FundingPeriods = new List <TrainingProgrammeFundingPeriod>
{
new TrainingProgrammeFundingPeriod
{
EffectiveFrom = new DateTime(2020, 2, 1),
EffectiveTo = new DateTime(2020, 3, 1),
FundingCap = 100
}
},
EffectiveFrom = new DateTime(2020, 2, 1),
EffectiveTo = new DateTime(2020, 3, 1),
Name = "Tit"
}
}
});
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetOverlappingApprenticeshipsQueryRequest>()))
.ReturnsAsync(new GetOverlappingApprenticeshipsQueryResponse
{
Overlaps = Enumerable.Empty <ApprenticeshipOverlapValidationResult>()
});
var result = await EmployerCommitmentOrchestrator.GetCommitmentDetails("HashedAccId", "HashedCmtId", "ExtUserId");
Assert.IsTrue(TestHelper.EnumerablesAreEqual(new[] { new KeyValuePair <string, string>("0", "Cost for Tit") }, result.Data.Warnings.AsEnumerable()));
}
public async Task ShouldValidateDateButNotCallReservationValidationsBecauseStartDateIsBlank()
{
var viewModel = new ApprenticeshipViewModel();
viewModel.ReservationId = Guid.NewGuid();
var updateModel = new UpdateApprenticeshipViewModel();
_mockValidator.Setup(m => m.ValidateAcademicYear(It.Is <UpdateApprenticeshipViewModel>(p => p.StartDate == null)))
.Returns(new Dictionary <string, string> {
{ "StartDate", "Start Date cannot be empty" }
});
var result = await Orchestrator.ValidateApprenticeship(viewModel, updateModel);
Assert.IsTrue(result.ContainsKey("StartDate"));
Assert.AreEqual("Start Date cannot be empty", result["StartDate"]);
MockMediator.Verify(m => m.SendAsync(It.IsAny <GetReservationValidationRequest>()), Times.Never);
}
public async Task ShouldReturnStatistics()
{
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetStatisticsRequest>())).ReturnsAsync(
new GetStatisticsResponse
{
Data = new Domain.Entities.Statistics
{
TotalApprenticeships = 100,
TotalCohorts = 25,
ActiveApprenticeships = 23
}
});
var result = await Orchestrator.GetStatistics();
result.TotalApprenticeships.Should().Be(100);
result.ActiveApprenticeships.Should().Be(23);
result.TotalCohorts.Should().Be(25);
}
public async Task ShouldCallMediatorToGetLegalEntityAgreementRequest()
{
//Arrange
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetAccountLegalEntitiesRequest>()))
.ReturnsAsync(new GetAccountLegalEntitiesResponse
{
LegalEntities = new List <LegalEntity> {
new LegalEntity {
Code = "123", Agreements = new List <Agreement>()
}
}
});
//Act
await EmployerCommitmentOrchestrator.GetFinishEditingViewModel("ABC123", "XYZ123", "ABC321");
//Assert
MockMediator.Verify(x => x.SendAsync(It.Is <GetAccountLegalEntitiesRequest>(c => c.HashedAccountId == "ABC123" && c.UserId == "XYZ123")), Times.Once);
}
public async Task Then_The_Provider_Is_Returned_From_Mediator()
{
//Arrange
var fixture = new Fixture();
var ukprn = fixture.Create <long>();
var provider = fixture.Create <ProviderResponse>();
MockMediator.Setup(m => m.SendAsync(It.Is <GetProviderQuery>(c => c.Ukprn.Equals(ukprn))))
.ReturnsAsync(new GetProviderQueryResponse()
{
Provider = provider
});
//Act
var actual = await Orchestrator.GetProvider(ukprn);
//Assert
actual.Provider.ShouldBeEquivalentTo(provider);
}
public async Task ThenAllCountsShouldBeZeroIfNoCommitments()
{
//Arrange
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentsQuery>()))
.ReturnsAsync(new GetCommitmentsResponse
{
Commitments = new List <CommitmentListItem>()
});
//Act
var result = await EmployerCommitmentOrchestrator.GetYourCohorts("ABC123", "ABC321");
//Assert
Assert.AreEqual(0, result.Data.DraftCount, "Incorrect DraftCount");
Assert.AreEqual(0, result.Data.ReadyForReviewCount, "Incorrect ReadyForReviewCount");
Assert.AreEqual(0, result.Data.WithProviderCount, "Incorrect WithProviderCount");
Assert.AreEqual(0, result.Data.TransferFundedCohortsCount, "IncorrectTransferFundedCohortsCount");
Assert.AreEqual(0, result.Data.RejectedTransferFundedCohortsCount, "IncorrectRejectedTransferFundedCohortsCount");
}
public async Task ShouldMapTransferConnectionCodeToResponse()
{
//Arrange
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetAccountLegalEntitiesRequest>()))
.ReturnsAsync(new GetAccountLegalEntitiesResponse
{
LegalEntities = new List <LegalEntity> {
new LegalEntity {
Code = "123", Agreements = new List <Agreement>()
}
}
});
//Act
var result = await EmployerCommitmentOrchestrator.GetLegalEntitySignedAgreementViewModel("ABC123", "T1234", "123", "C789", "123EDC");
//Assert
result.Data.TransferConnectionCode.Should().Be("T1234");
}
public async Task ThenResultIsMappedCommitmentAgreementsReturnedFromGetCommitmentAgreementsQueryHandler()
{
const long providerId = 321L;
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetCommitmentAgreementsRequest>()))
.ReturnsAsync(new GetCommitmentAgreementsResponse
{
Data = new List <CommitmentAgreement>
{
new CommitmentAgreement
{
Reference = "ref",
LegalEntityName = "len",
AccountLegalEntityPublicHashedId = "aleHash"
}
}
});
var mappedCommitmentAgreement = new Types.Commitment.CommitmentAgreement
{
Reference = "mapped ref",
LegalEntityName = "mapped len",
AccountLegalEntityPublicHashedId = "mapped aleHash"
};
var mockCommitmentMapper = new Mock <ICommitmentMapper>();
mockCommitmentMapper.Setup(m => m.Map(It.IsAny <Domain.Entities.CommitmentAgreement>()))
.Returns(TestHelper.Clone(mappedCommitmentAgreement));
Orchestrator = new ProviderOrchestrator(
MockMediator.Object,
Mock.Of <ICommitmentsLogger>(),
MockFacetMapper.Object,
MockApprenticeshipFilter.Object,
new ApprenticeshipMapper(),
mockCommitmentMapper.Object);
var result = await Orchestrator.GetCommitmentAgreements(providerId);
Assert.IsTrue(TestHelper.EnumerablesAreEqual(new[] { mappedCommitmentAgreement }, result));
}
public async Task ShouldCallMediatorToCreate()
{
//Arrange
var model = new ApprenticeshipViewModel
{
HashedAccountId = "ABC123",
HashedCommitmentId = "ABC321"
};
var userName = "******";
var userEmail = "*****@*****.**";
//Act
await EmployerCommitmentOrchestrator.CreateApprenticeship(model, "externalUserId", userName, userEmail);
//Assert
MockMediator.Verify(
x => x.SendAsync(It.Is <CreateApprenticeshipCommand>(c => c.AccountId == 123L && c.UserId == "externalUserId" && c.UserDisplayName == userName && c.UserEmailAddress == userEmail)),
Times.Once);
}
public async Task Create_Valid_PublishesLibraryCreatedDomainEvent()
{
await ExecuteWithDb((db) =>
{
var handler = new CreateLibraryCommandHandler(
MockMediator.Object,
db,
Mapper,
MockAuthorizationService.Object);
var dto = SetupLibraryDto(RandomFactory.GetLibraryName());
return(handler.Handle(new CreateLibraryCommand()
{
Library = dto
}, default));
}, (result, db) =>
{
MockMediator.Verify(x => x.Publish(It.IsAny <LibraryCreatedDomainEvent>(), It.IsAny <CancellationToken>()), Times.Once);
});
}
public async Task Create_Valid_PublishesGroupCreatedDomainEvent()
{
await ExecuteWithDb((db) =>
{
var handler = new CreateGroupCommandHandler(
MockMediator.Object,
db,
Mapper,
MockAuthorizationService.Object);
var dto = SeedHelper.CreateValidNewGroupDto(db, Mapper);
return(handler.Handle(new CreateGroupCommand()
{
Group = dto
}, default));
}, (result, db) =>
{
MockMediator.Verify(x => x.Publish(It.IsAny <GroupCreatedDomainEvent>(), It.IsAny <CancellationToken>()), Times.Once);
});
}
public async Task ThenCorrectCommitmentsAreReturned()
{
//Arrange
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentsQuery>()))
.ReturnsAsync(new GetCommitmentsResponse
{
Commitments = GetTestCommitmentsOfStatus(1,
RequestStatus.WithProviderForApproval, // 1: should be returned
RequestStatus.SentForReview, // 2: should be returned
RequestStatus.SentToProvider, // 3: should be returned
RequestStatus.ReadyForReview // 4: should not be returned
).ToList()
});
//Act
var result = await EmployerCommitmentOrchestrator.GetAllWithProvider("ABC123", "ABC321");
//Assert
Assert.AreEqual(3, result.Data.Commitments.Count());
CollectionAssert.AreEquivalent(new[] { "1", "2", "3" }, result.Data.Commitments.Select(c => c.Name));
}
public void Arrange()
{
_commitmentView = new CommitmentView
{
Id = 123,
LegalEntityId = "123",
EditStatus = EditStatus.EmployerOnly
};
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetCommitmentQueryRequest>()))
.ReturnsAsync(new GetCommitmentQueryResponse
{
Commitment = _commitmentView
});
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetOverlappingApprenticeshipsQueryRequest>()))
.ReturnsAsync(
new GetOverlappingApprenticeshipsQueryResponse
{
Overlaps = Enumerable.Empty <ApprenticeshipOverlapValidationResult>()
});
}
public async Task ShouldSetStatusTextForApprenticeshipNotStarted(int nowMonth, int nowDay, int startMonth)
{
MockDateTime.Setup(m => m.Now).Returns(new DateTime(1998, nowMonth, nowDay));
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipQueryRequest>()))
.ReturnsAsync(new GetApprenticeshipQueryResponse
{
Apprenticeship =
new Apprenticeship
{
PaymentStatus = PaymentStatus.Active,
StartDate = new DateTime(1998, startMonth, 1)
}
});
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetApprenticeshipUpdateRequest>()))
.ReturnsAsync(new GetApprenticeshipUpdateResponse());
var result = await Orchestrator.GetApprenticeship("hashedAccountId", "hashedApprenticeshipId", "UserId");
MockMediator.Verify(m => m.SendAsync(It.IsAny <GetApprenticeshipQueryRequest>()), Times.Once);
result.Data.Status.Should().Be("Waiting to start");
}
public async Task ShouldReturnApprenticeshipDetails()
{
//Arrange
var expected = new Apprenticeship
{
FirstName = "John",
LastName = "Smith",
DateOfBirth = new DateTime(1976, 9, 1)
};
MockMediator.Setup(x => x.SendAsync(It.IsAny <GetApprenticeshipQueryRequest>()))
.ReturnsAsync(new GetApprenticeshipQueryResponse
{
Apprenticeship = expected
});
//Act
var viewModel = await EmployerCommitmentOrchestrator.GetDeleteApprenticeshipViewModel("ABC123", "EXT789", "ABC321", "ABC456");
//Assert
Assert.AreEqual(String.Format($"{expected.FirstName} {expected.LastName}"), viewModel.Data.ApprenticeshipName);
Assert.AreEqual(expected.DateOfBirth.Value.ToGdsFormat(), viewModel.Data.DateOfBirth);
}
public async Task ShouldCallTheMediatorBulkUpload()
{
var providerId = 1L;
var commitmentId = 2L;
var request = new BulkApprenticeshipRequest
{
LastUpdatedByInfo = new LastUpdateInfo {
EmailAddress = "*****@*****.**", Name = "Bob"
},
UserId = "User",
Apprenticeships = new List <Types.Apprenticeship.Apprenticeship>()
};
await Orchestrator.CreateApprenticeships(providerId, commitmentId, request);
MockMediator.Verify(
x =>
x.SendAsync(
It.Is <BulkUploadApprenticeshipsCommand>(
y =>
y.Caller.Id == providerId && y.Caller.CallerType == CallerType.Provider && y.CommitmentId == commitmentId && y.UserId == request.UserId &&
y.UserName == request.LastUpdatedByInfo.Name)), Times.Once);
}
public override void Setup()
{
base.Setup();
_handler = new HelpHandler(MockTwitchClient.Object, MockMediator.Object);
_fakeStaticCommands = new ValidStaticCommands
{
Commands = new List <StaticCommandInfo>
{
new StaticCommandInfo {
Command = "!foo", Content = "foo content " + Guid.NewGuid()
},
new StaticCommandInfo {
Command = "!bar", Content = "bar content " + Guid.NewGuid()
},
new StaticCommandInfo {
Command = "!baz", Content = "foo content " + Guid.NewGuid()
},
}
};
MockMediator.Setup(m =>
m.Send <ValidStaticCommands>(It.IsAny <StaticCommandsLookup>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_fakeStaticCommands);
}
public async Task ThereIsAnUpdate()
{
var update = new Fixture().Create <Domain.Entities.ApprenticeshipUpdate>();
MockMediator.Setup(m => m.SendAsync(It.IsAny <GetPendingApprenticeshipUpdateRequest>()))
.ReturnsAsync(new GetPendingApprenticeshipUpdateResponse
{
Data = update
});
var result = await Orchestrator.GetPendingApprenticeshipUpdate(666, 999);
result.Should().NotBeNull();
result.ShouldBeEquivalentTo(update, config =>
config
.ExcludingMissingMembers()
.Excluding(m => m.ULN)
.Excluding(m => m.EmployerRef)
.Excluding(m => m.ProviderRef)
.Excluding(m => m.UpdateOrigin)
.Excluding(m => m.EffectiveFromDate)
.Excluding(m => m.EffectiveToDate)
);
}
public void Arrange()
{
MockMediator.Setup(x => x.SendAsync(It.IsAny <AcceptApprenticeshipChangeCommand>())).ReturnsAsync(new Unit());
MockMediator.Setup(x => x.SendAsync(It.IsAny <RejectApprenticeshipChangeCommand>())).ReturnsAsync(new Unit());
MockMediator.Setup(x => x.SendAsync(It.IsAny <UndoApprenticeshipChangeCommand>())).ReturnsAsync(new Unit());
}
public void Arrange()
{
MockMediator.Setup(x => x.SendAsync(It.IsAny <UpdateApprenticeshipStopDateCommand>())).ReturnsAsync(new Unit());
}
public async Task ThenAppropriateCommandIsSentToMediator()
{
await Orchestrator.TriageDataLock(1, 2, new DataLockTriageSubmission(), new Caller(12345, CallerType.Provider));
MockMediator.Verify(x => x.SendAsync(It.IsAny <TriageDataLockCommand>()), Times.Once);
}
