public async Task ThenItShouldRaiseEventForGroupIfAlreadyExistsAndUpdated(PointInTimeGroup stagingGroup)
{
// Arrange
var managementGroup = new ManagementGroup {
Identifier = stagingGroup.Uid.ToString()
};
_mapperMock.Setup(m => m.MapAsync <ManagementGroup>(It.IsAny <PointInTimeGroup>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(managementGroup);
_groupRepositoryMock.Setup(r => r.GetGroupFromStagingAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(stagingGroup);
_groupRepositoryMock.Setup(r => r.GetGroupAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(CloneWithChanges(stagingGroup, stagingGroup.GroupName + "-updated", false));
_establishmentRepositoryMock.Setup(r => r.GetEstablishmentFromStagingAsync(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new PointInTimeEstablishment());
// Act
await _manager.ProcessGroupAsync(stagingGroup.Uid, new[] { 1000001L }, stagingGroup.PointInTime, _cancellationToken);
// Assert
_eventPublisherMock.Verify(p => p.PublishManagementGroupUpdatedAsync(
managementGroup,
stagingGroup.PointInTime,
_cancellationToken),
Times.Once);
}
private PointInTimeGroup CloneWithChanges(PointInTimeGroup group, string groupName = null, bool?isCurrent = null)
{
var clone = Clone(group);
if (groupName != null)
{
clone.GroupName = groupName;
}
if (isCurrent.HasValue)
{
clone.IsCurrent = isCurrent.Value;
}
return(clone);
}
public async Task ThenItShouldStoreTheGroupIfDoesNotAlreadyExist(PointInTimeGroup stagingGroup)
{
// Arrange
_groupRepositoryMock.Setup(r => r.GetGroupFromStagingAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(stagingGroup);
_establishmentRepositoryMock.Setup(r => r.GetEstablishmentFromStagingAsync(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new PointInTimeEstablishment());
// Act
await _manager.ProcessGroupAsync(stagingGroup.Uid, new[] { 1000001L }, stagingGroup.PointInTime, _cancellationToken);
// Assert
_groupRepositoryMock.Verify(r => r.StoreAsync(
It.Is <PointInTimeGroup[]>(toStore =>
toStore.Length == 1 &&
toStore[0] == stagingGroup),
_cancellationToken),
Times.Once);
}
public async Task ThenItShouldStoreEstablishmentIfAlreadyExistsAndUpdated(PointInTimeGroup stagingGroup, PointInTimeEstablishment stagingEstablishment)
{
// Arrange
_groupRepositoryMock.Setup(r => r.GetGroupFromStagingAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(stagingGroup);
_establishmentRepositoryMock.Setup(r =>
r.GetEstablishmentFromStagingAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(stagingEstablishment);
_establishmentRepositoryMock.Setup(r => r.GetEstablishmentAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(CloneWithChanges(stagingEstablishment, stagingEstablishment.EstablishmentName + "-updated", false));
// Act
await _manager.ProcessGroupAsync(stagingGroup.Uid, new[] { stagingEstablishment.Urn }, stagingGroup.PointInTime, _cancellationToken);
// Assert
_establishmentRepositoryMock.Verify(r => r.StoreAsync(
It.Is <PointInTimeEstablishment[]>(toStore =>
toStore.Length == 1 &&
toStore[0] == stagingEstablishment),
_cancellationToken),
Times.Once);
}
public async Task ThenItShouldMapManagementGroupToFederationIfAvailable(Establishment source, long uid)
{
EnsureManagmentGroupCodes(source, federationUid: uid);
var federation = new PointInTimeGroup();
var managementGroup = new ManagementGroup();
_groupRepositoryMock.Setup(r =>
r.GetGroupAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(federation);
_mapperMock.Setup(m =>
m.MapAsync <ManagementGroup>(It.IsAny <Group>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(managementGroup);
var actual = await _mapper.MapAsync <LearningProvider>(source, _cancellationToken);
Assert.IsNotNull(actual.ManagementGroup);
Assert.AreSame(managementGroup, actual.ManagementGroup);
_groupRepositoryMock.Verify(r => r.GetGroupAsync(uid, _cancellationToken),
Times.Once);
_mapperMock.Verify(m => m.MapAsync <ManagementGroup>(federation, _cancellationToken),
Times.Once);
}
private async Task StoreGroupAndRaiseEventAsync(
PointInTimeGroup staging,
bool isUpdate,
CancellationToken cancellationToken)
{
var current = await _groupRepository.GetGroupAsync(staging.Uid, cancellationToken);
staging.IsCurrent = current == null || staging.PointInTime > current.PointInTime;
if (current != null && staging.IsCurrent)
{
current.IsCurrent = false;
}
var toStore = current == null || current.IsCurrent
? new[] { staging }
: new[] { current, staging };
await _groupRepository.StoreAsync(toStore, cancellationToken);
_logger.Debug($"Stored group {staging.Uid} in repository");
var managementGroup = await _mapper.MapAsync <ManagementGroup>(staging, cancellationToken);
managementGroup._Lineage = null;
if (isUpdate)
{
await _eventPublisher.PublishManagementGroupUpdatedAsync(managementGroup, staging.PointInTime, cancellationToken);
}
else
{
await _eventPublisher.PublishManagementGroupCreatedAsync(managementGroup, staging.PointInTime, cancellationToken);
}
_logger.Debug($"Sent event for group {staging.Uid}");
}
public async Task ThenItShouldRaiseEventForEstablishmentIfAlreadyExistsNotUpdatedButGroupIsUpdated(PointInTimeGroup stagingGroup, PointInTimeEstablishment stagingEstablishment)
{
// Arrange
var learningProvider = new LearningProvider {
Urn = stagingEstablishment.Urn
};
_mapperMock.Setup(m => m.MapAsync <LearningProvider>(It.IsAny <PointInTimeEstablishment>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(learningProvider);
_groupRepositoryMock.Setup(r => r.GetGroupFromStagingAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(stagingGroup);
_groupRepositoryMock.Setup(r => r.GetGroupAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(CloneWithChanges(stagingGroup, stagingGroup.GroupName + "-updated", false));
_establishmentRepositoryMock.Setup(r =>
r.GetEstablishmentFromStagingAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(stagingEstablishment);
_establishmentRepositoryMock.Setup(r => r.GetEstablishmentAsync(stagingEstablishment.Urn, It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Clone(stagingEstablishment));
// Act
await _manager.ProcessGroupAsync(stagingGroup.Uid, new[] { stagingEstablishment.Urn }, stagingGroup.PointInTime, _cancellationToken);
// Assert
_eventPublisherMock.Verify(p => p.PublishLearningProviderUpdatedAsync(
learningProvider,
stagingEstablishment.PointInTime,
_cancellationToken),
Times.Once);
}
public Task StoreAsync(PointInTimeGroup @group, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
