public void VerifyEventEmitted()
{
var emittedEvent = (DraftApprenticeshipDeletedEvent)UnitOfWorkContext.GetEvents().Single(x => x is DraftApprenticeshipDeletedEvent);
emittedEvent.DraftApprenticeshipId = DeletionTarget.Id;
emittedEvent.CohortId = Cohort.Id;
emittedEvent.ReservationId = DeletionTarget.ReservationId;
emittedEvent.Uln = DeletionTarget.Uln;
}
public void VerifyApprenticeshipCompletedEventIsPublished()
{
var apprenticeshipCompletedEvent = _unitOfWorkContext
.GetEvents()
.OfType <ApprenticeshipCompletedEvent>()
.First(x =>
x.CompletionDate == _completionDate &&
x.ApprenticeshipId == _apprenticeship.Id);
Assert.NotNull(apprenticeshipCompletedEvent);
}
public void VerifyTransferRequestRejectedEventIsPublished()
{
var list = _unitOfWorkContext.GetEvents()
.OfType <TransferRequestRejectedEvent>()
.ToList();
var rejectedEvent = list
.SingleOrDefault(x => x.TransferRequestId == _transferRequestId);
Assert.NotNull(rejectedEvent);
Assert.AreEqual(1, list.Count);
Assert.AreEqual(_cohort.Id, rejectedEvent.CohortId);
Assert.AreEqual(_rejectedOnDate, rejectedEvent.RejectedOn);
Assert.AreSame(_userInfo, rejectedEvent.UserInfo);
}
public void VerifyApprenticeshipTracking()
{
Assert.IsNotNull(UnitOfWorkContext.GetEvents().SingleOrDefault(x => x is EntityStateChangedEvent @event &&
@event.EntityType == nameof(Apprenticeship) &&
@event.ProviderId == Apprenticeship.Cohort.ProviderId &&
@event.EmployerAccountId == Apprenticeship.Cohort.EmployerAccountId));
}
public void AssertTransferRequestCreatedEventWasPublished()
{
var @event = UnitOfWorkContext.GetEvents().OfType <TransferRequestCreatedEvent>().First();
Assert.AreEqual(CohortId, @event.CohortId);
Assert.AreEqual(LastApprovedByParty, @event.LastApprovedByParty);
Assert.IsNotNull(@event.TransferRequestId);
}
public void VerifyCohortDeletedEventIsEmittedAndWasApprovedBy(Party party)
{
var emittedEvent = (CohortDeletedEvent)UnitOfWorkContext.GetEvents().Single(x => x is CohortDeletedEvent);
Assert.AreEqual(Cohort.Id, emittedEvent.CohortId);
Assert.AreEqual(Cohort.EmployerAccountId, emittedEvent.AccountId);
Assert.AreEqual(Cohort.ProviderId, emittedEvent.ProviderId);
Assert.IsTrue(emittedEvent.ApprovedBy.HasFlag(party));
}
public void VerifyCohortWithChangeOfPartyRequestFullyApprovedEventIsEmitted(Party modifyingParty)
{
var emittedEvent = (CohortWithChangeOfPartyFullyApprovedEvent)UnitOfWorkContext.GetEvents()
.Single(x => x is CohortWithChangeOfPartyFullyApprovedEvent);
Assert.AreEqual(Cohort.Id, emittedEvent.CohortId);
Assert.AreEqual(Cohort.ChangeOfPartyRequestId, emittedEvent.ChangeOfPartyRequestId);
Assert.AreEqual(UserInfo, emittedEvent.UserInfo);
Assert.AreEqual(modifyingParty, emittedEvent.ApprovedBy);
}
public void VerifyTransferRequestApprovedEventIsPublished()
{
var list = UnitOfWorkContext.GetEvents().OfType <TransferRequestApprovedEvent>().ToList();
Assert.AreEqual(1, list.Count);
Assert.AreEqual(Cohort.Id, list[0].CohortId);
Assert.AreEqual(TransferRequest.Id, list[0].TransferRequestId);
Assert.AreEqual(TransferSenderUserInfo, list[0].UserInfo);
Assert.AreEqual(Now, list[0].ApprovedOn);
}
public void VerifyDraftApprenticeshipCreatedEventIsPublished()
{
var draftApprenticeship = Cohort.Apprenticeships.Single();
UnitOfWorkContext.GetEvents().OfType <DraftApprenticeshipCreatedEvent>().Should().ContainSingle(e =>
e.CohortId == Cohort.Id &&
e.DraftApprenticeshipId == draftApprenticeship.Id &&
e.Uln == draftApprenticeship.Uln &&
e.ReservationId == draftApprenticeship.ReservationId &&
e.CreatedOn == draftApprenticeship.CreatedOn);
}
public void VerifyEntityIsBeingTracked()
{
var list = UnitOfWorkContext.GetEvents().OfType <EntityStateChangedEvent>().Where(x => x.StateChangeType == UserAction.RejectTransferRequest).ToList();
Assert.AreEqual(1, list.Count);
Assert.AreEqual(UserAction.RejectTransferRequest, list[0].StateChangeType);
Assert.AreEqual(Cohort.Id, list[0].EntityId);
Assert.AreEqual(TransferRequestRejectedEvent.UserInfo.UserDisplayName, list[0].UpdatingUserName);
Assert.AreEqual(Party.TransferSender, list[0].UpdatingParty);
}
public void VerifyDeleteEvent()
{
Assert.IsNotNull(UnitOfWorkContext.GetEvents().OfType <EntityStateChangedEvent>().Single(x =>
x.ProviderId == ProviderId &&
x.EmployerAccountId == EmployerAccountId &&
x.EntityId == TestDeleteTrackableEntity.Id &&
x.EntityType == TestDeleteTrackableEntity.GetType().Name&&
x.InitialState == JsonConvert.SerializeObject(TestDeleteInitialState) &&
x.StateChangeType == UserAction &&
x.UpdatedState == null &&
x.UpdatingParty == Party &&
x.UpdatingUserId == UserInfo.UserId &&
x.UpdatingUserName == UserInfo.UserDisplayName
));
}
public async Task ThenShouldPublishRejectedTransferConnectionInvitationEvent()
{
await _handler.Handle(_command);
var messages = _unitOfWorkContext.GetEvents().ToList();
var message = messages.OfType <RejectedTransferConnectionRequestEvent>().FirstOrDefault();
Assert.That(messages.Count, Is.EqualTo(1));
Assert.That(message, Is.Not.Null);
Assert.That(message.Created, Is.EqualTo(_transferConnectionInvitation.Changes.Select(c => c.CreatedDate).Cast <DateTime?>().SingleOrDefault()));
Assert.That(message.ReceiverAccountHashedId, Is.EqualTo(_receiverAccount.HashedId));
Assert.That(message.ReceiverAccountId, Is.EqualTo(_receiverAccount.Id));
Assert.That(message.ReceiverAccountName, Is.EqualTo(_receiverAccount.Name));
Assert.That(message.RejectorUserRef, Is.EqualTo(_receiverUser.Ref));
Assert.That(message.RejectorUserId, Is.EqualTo(_receiverUser.Id));
Assert.That(message.RejectorUserName, Is.EqualTo(_receiverUser.FullName));
Assert.That(message.SenderAccountHashedId, Is.EqualTo(_senderAccount.HashedId));
Assert.That(message.SenderAccountId, Is.EqualTo(_senderAccount.Id));
Assert.That(message.SenderAccountName, Is.EqualTo(_senderAccount.Name));
Assert.That(message.TransferConnectionRequestId, Is.EqualTo(_transferConnectionInvitation.Id));
}
public void VerifyEvent()
{
Assert.IsNotNull(UnitOfWorkContext.GetEvents().SingleOrDefault(x => x is ChangeOfPartyRequestCreatedEvent));
}
public void VerifyCohortTracking()
{
Assert.IsNotNull(UnitOfWorkContext.GetEvents().SingleOrDefault(x => x is EntityStateChangedEvent @event &&
@event.EntityType ==
nameof(Cohort)));
}
public void VerifyDraftApprenticeshipTracking()
{
Assert.IsNotNull(UnitOfWorkContext.GetEvents().SingleOrDefault(x => x is EntityStateChangedEvent @event &&
@event.EntityType ==
nameof(DraftApprenticeship)));
}
public void VerifyCohortAssignedToProviderEventIsPublished()
{
Assert.IsNotNull(UnitOfWorkContext.GetEvents().SingleOrDefault(x => x is CohortAssignedToProviderEvent));
}
public void VerifyCohortWithChangeOfPartyRequestEventIsPublished()
{
Assert.IsNotNull(UnitOfWorkContext.GetEvents().SingleOrDefault(x => x is CohortWithChangeOfPartyUpdatedEvent @event &&
@event.CohortId == Cohort.Id));
}
public void VerifyTracking()
{
Assert.IsNotNull(_unitOfWorkContext.GetEvents().SingleOrDefault(x => x is EntityStateChangedEvent @event &&
@event.EntityType ==
nameof(ChangeOfPartyRequest)));
}
public T GetEvent <T>()
{
return(UnitOfWorkContext.GetEvents().OfType <T>().SingleOrDefault());
}
public void VerifyTransferRequestApprovedEventIsNotPublished()
{
var list = UnitOfWorkContext.GetEvents().OfType <TransferRequestApprovedEvent>().ToList();
Assert.AreEqual(0, list.Count);
}
