public LifeCycleStageWasRemoved(
PublicServiceId publicServiceId,
LifeCycleStageId lifeCycleStageId)
{
PublicServiceId = publicServiceId;
LifeCycleStageId = lifeCycleStageId;
}
public Task DoesNotSetNextLifeCycleStageWhenDayHasPassedWhenThatLifeCycleStageWasRemoved()
{
var clockProviderStub = new ClockProviderStub(Today);
var publicServiceId = new PublicServiceId("DVR000000001");
var publicServiceName = new PublicServiceName("Test");
var events = new object[]
{
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), LifeCycleStageType.Active, PeriodOverlappingWithToday),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(2), LifeCycleStageType.PhasingOut, PeriodOverlappingWithTomorrow),
new LifeCycleStageWasRemoved(publicServiceId, LifeCycleStageId.FromNumber(2)),
new ClockHasTicked(Tomorrow),
};
return(new PublicServiceListProjections(clockProviderStub)
.Scenario()
.Given(events)
.Expect(new PublicServiceListItem
{
Name = publicServiceName,
PublicServiceId = publicServiceId,
CurrentLifeCycleStageType = null,
CurrentLifeCycleStageId = null,
CurrentLifeCycleStageEndsAt = null,
}));
}
public async Task WhenPeriodOfLifeCycleStageWasChanged()
{
var projection = new PublicServiceLifeCycleListProjections();
var resolver = ConcurrentResolve.WhenEqualToHandlerMessageType(projection.Handlers);
var stageWasAddedToLifeCycle = _fixture.Create <StageWasAddedToLifeCycle>();
var periodOfLifeCycleStageWasChanged = new PeriodOfLifeCycleStageWasChanged(
new PublicServiceId(stageWasAddedToLifeCycle.PublicServiceId),
LifeCycleStageId.FromNumber(stageWasAddedToLifeCycle.LifeCycleStageId),
_fixture.Create <LifeCycleStagePeriod>());
await new ConnectedProjectionScenario <BackofficeContext>(resolver)
.Given(
new Envelope <StageWasAddedToLifeCycle>(new Envelope(stageWasAddedToLifeCycle, new Dictionary <string, object>())),
new Envelope <PeriodOfLifeCycleStageWasChanged>(new Envelope(periodOfLifeCycleStageWasChanged, new Dictionary <string, object>())))
.Verify(async context =>
{
var publicService =
await context.PublicServiceLifeCycleList.FirstAsync(a =>
a.PublicServiceId == stageWasAddedToLifeCycle.PublicServiceId && a.LifeCycleStageId == stageWasAddedToLifeCycle.LifeCycleStageId);
publicService.Should().BeEquivalentTo(new PublicServiceLifeCycleItem()
{
LifeCycleStageId = stageWasAddedToLifeCycle.LifeCycleStageId,
PublicServiceId = stageWasAddedToLifeCycle.PublicServiceId,
LifeCycleStageType = stageWasAddedToLifeCycle.LifeCycleStageType,
From = periodOfLifeCycleStageWasChanged.From,
To = periodOfLifeCycleStageWasChanged.To
});
return(VerificationResult.Pass());
})
.Assert();
}
public Task DoesNotClearLifeCycleStageWhenAnotherLifeCycleStageNoLongerOverlapsWithToday()
{
var clockProviderStub = new ClockProviderStub(Today);
var publicServiceId = new PublicServiceId("DVR000000001");
var publicServiceName = new PublicServiceName("Test");
var events = new object[]
{
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), LifeCycleStageType.Active, PeriodOverlappingWithToday),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(2), LifeCycleStageType.PhasingOut, PeriodOverlappingWithTomorrow),
new PeriodOfLifeCycleStageWasChanged(publicServiceId, LifeCycleStageId.FromNumber(2), PeriodOverlappingWithYesterday),
};
return(new PublicServiceListProjections(clockProviderStub)
.Scenario()
.Given(events)
.Expect(new PublicServiceListItem
{
Name = publicServiceName,
PublicServiceId = publicServiceId,
CurrentLifeCycleStageType = "Active",
CurrentLifeCycleStageId = 1,
CurrentLifeCycleStageEndsAt = LocalDate.FromDateTime(Today),
}));
}
public async Task WhenLifeCycleStageWasRemoved()
{
var projection = new PublicServiceLifeCycleListProjections();
var resolver = ConcurrentResolve.WhenEqualToHandlerMessageType(projection.Handlers);
var stageWasAddedToLifeCycle = _fixture.Create <StageWasAddedToLifeCycle>();
var lifeCycleStageWasRemoved = new LifeCycleStageWasRemoved(
new PublicServiceId(stageWasAddedToLifeCycle.PublicServiceId),
LifeCycleStageId.FromNumber(stageWasAddedToLifeCycle.LifeCycleStageId));
await new ConnectedProjectionScenario <BackofficeContext>(resolver)
.Given(
new Envelope <StageWasAddedToLifeCycle>(new Envelope(stageWasAddedToLifeCycle, new Dictionary <string, object>())),
new Envelope <LifeCycleStageWasRemoved>(new Envelope(lifeCycleStageWasRemoved, new Dictionary <string, object>())))
.Verify(async context =>
{
var publicService =
await context.PublicServiceLifeCycleList.FirstOrDefaultAsync(a =>
a.PublicServiceId == stageWasAddedToLifeCycle.PublicServiceId && a.LifeCycleStageId == stageWasAddedToLifeCycle.LifeCycleStageId);
publicService.Should().BeNull();
return(VerificationResult.Pass());
})
.Assert();
}
public RemoveStageFromLifeCycle(
PublicServiceId publicServiceId,
LifeCycleStageId lifeCycleStageId)
{
PublicServiceId = publicServiceId;
LifeCycleStageId = lifeCycleStageId;
}
private void When(StageWasAddedToLifeCycle @event)
{
_lastUsedId = LifeCycleStageId.FromNumber(@event.LifeCycleStageId);
var lifeCycleStagePeriod = new LifeCycleStagePeriod(new ValidFrom(@event.From), new ValidTo(@event.To));
_lifeCycleStagePeriods[@event.LifeCycleStageId] = lifeCycleStagePeriod;
}
public ChangePeriodOfLifeCycleStage(
PublicServiceId publicServiceId,
LifeCycleStageId lifeCycleStageId,
LifeCycleStagePeriod lifeCycleStagePeriod)
{
PublicServiceId = publicServiceId;
LifeCycleStageId = lifeCycleStageId;
LifeCycleStagePeriod = lifeCycleStagePeriod;
}
public static ChangePeriodOfLifeCycleStage Map(string id, int lifeCycleStageId, ChangePeriodOfLifeCycleStageRequest message)
{
return(new ChangePeriodOfLifeCycleStage(
new PublicServiceId(id),
LifeCycleStageId.FromNumber(lifeCycleStageId),
new LifeCycleStagePeriod(
new ValidFrom(message.Vanaf.HasValue ? LocalDate.FromDateTime(message.Vanaf.Value) : (LocalDate?)null),
new ValidTo(message.Tot.HasValue ? LocalDate.FromDateTime(message.Tot.Value) : (LocalDate?)null))));
}
public PeriodOfLifeCycleStageWasChanged(
PublicServiceId publicServiceId,
LifeCycleStageId lifeCycleStageId,
LifeCycleStagePeriod period)
{
PublicServiceId = publicServiceId;
LifeCycleStageId = lifeCycleStageId;
From = period.Start;
To = period.End;
}
public static void CustomizeStageWasAddedToLifeCycle(this IFixture fixture) =>
fixture.Customize <StageWasAddedToLifeCycle>(customization =>
customization
.FromFactory(generator =>
new StageWasAddedToLifeCycle(
PublicServiceId.FromNumber(fixture.Create <int>()),
LifeCycleStageId.FromNumber(fixture.Create <int>()),
LifeCycleStageType.All[generator.Next() % LifeCycleStageType.All.Length],
fixture.Create <LifeCycleStagePeriod>()
)).OmitAutoProperties());
public StageWasAddedToLifeCycle(PublicServiceId publicServiceId,
LifeCycleStageId lifeCycleStageId,
LifeCycleStageType lifeCycleStageType,
LifeCycleStagePeriod period)
{
PublicServiceId = publicServiceId;
LifeCycleStageId = lifeCycleStageId;
LifeCycleStageType = lifeCycleStageType;
From = period.Start;
To = period.End;
}
public void RemoveStage(LifeCycleStageId lifeCycleStageId)
{
if (!_lifeCycleStagePeriods.ContainsKey(lifeCycleStageId))
{
throw new LifeCycleStageWithGivenIdNotFound(lifeCycleStageId);
}
Apply(
new LifeCycleStageWasRemoved(
_publicServiceId,
lifeCycleStageId));
}
public void WithValidData(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType,
LifeCycleStagePeriod period)
{
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered))
.When(new AddStageToLifeCycle(publicServiceId, lifeCycleStageType, period))
.Then(publicServiceId,
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStageType, period)));
}
public async Task <IActionResult> RemoveStageFromLifeCycle(
[FromCommandId] Guid commandId,
[FromRoute] string id,
[FromRoute] int faseId,
CancellationToken cancellationToken = default)
{
return(Accepted(
await Bus.Dispatch(
commandId,
new RemoveStageFromLifeCycle(new PublicServiceId(id), LifeCycleStageId.FromNumber(faseId)),
GetMetadata(),
cancellationToken)));
}
public void CannotRemoveLifeCycleStageOnRemovedPublicService(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
ReasonForRemoval reasonForRemoval,
LifeCycleStagePeriod period)
{
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), LifeCycleStageType.PhasingOut, period),
new PublicServiceWasRemoved(publicServiceId, reasonForRemoval))
.When(new RemoveStageFromLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1)))
.Throws(new CannotPerformActionOnRemovedPublicService()));
}
public void CantRemoveARemovedLifeCycleStage(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStagePeriod period)
{
Assert(
new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), LifeCycleStageType.PhasingOut, period),
new LifeCycleStageWasRemoved(publicServiceId, LifeCycleStageId.FromNumber(1)))
.When(new RemoveStageFromLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1)))
.Throws(new LifeCycleStageWithGivenIdNotFound(1)));
}
public void WithValidData(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType,
LifeCycleStagePeriod period,
LifeCycleStageId lifeCycleStageLocalId)
{
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, lifeCycleStageLocalId, lifeCycleStageType, period))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, lifeCycleStageLocalId, period))
.Then(publicServiceId,
new PeriodOfLifeCycleStageWasChanged(publicServiceId, lifeCycleStageLocalId, period)));
}
public void ChangePeriod(LifeCycleStageId lifeCycleStageId, LifeCycleStagePeriod period)
{
if (_lifeCycleStagePeriods
.Where(pair => pair.Key != lifeCycleStageId)
.Any(pair => pair.Value.OverlapsWith(period)))
{
throw new LifeCycleCannotHaveOverlappingPeriods();
}
Apply(
new PeriodOfLifeCycleStageWasChanged(
_publicServiceId,
lifeCycleStageId,
period));
}
public void LifeCycleCannotHaveOverlappingPeriods(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStage1,
LifeCycleStageType lifeCycleStage2)
{
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, LifeCycleStageId.FromNumber(1), 1), new ValidTo(2020, LifeCycleStageId.FromNumber(1), 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2019, LifeCycleStageId.FromNumber(1), 1), new ValidTo(2021, LifeCycleStageId.FromNumber(1), 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStage1, period1))
.When(new AddStageToLifeCycle(publicServiceId, lifeCycleStage2, period2))
.Throws(new LifeCycleCannotHaveOverlappingPeriods()));
}
public void CannotChangePeriodOfLifeCycleStageOnRemovedPublicService(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
ReasonForRemoval reasonForRemoval,
LifeCycleStageType lifeCycleStageType,
LifeCycleStagePeriod period,
LifeCycleStageId lifeCycleStageId)
{
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, lifeCycleStageId, lifeCycleStageType, period),
new PublicServiceWasRemoved(publicServiceId, reasonForRemoval))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, lifeCycleStageId, period))
.Throws(new CannotPerformActionOnRemovedPublicService()));
}
public void LifeCycleOverlapsTakesChangesIntoAccount(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType)
{
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2018, 1, 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2020, 1, 2), new ValidTo(2022, 1, 1));
// Combining period2 with period3 will cause an overlap.
var period3 = new LifeCycleStagePeriod(new ValidFrom(2019, 1, 1), new ValidTo(2021, 1, 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStageType, period1),
new PeriodOfLifeCycleStageWasChanged(publicServiceId, LifeCycleStageId.FromNumber(1), period2))
.When(new AddStageToLifeCycle(publicServiceId, lifeCycleStageType, period3))
.Throws(new LifeCycleCannotHaveOverlappingPeriods()));
}
public void LifeCycleCannotHaveOverlappingPeriods(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType)
{
// These two periods are ok because they don't overlap
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2020, 1, 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2020, 1, 2), new ValidTo(2021, 1, 1));
// Combining period1 with period3 will cause an overlap, however.
var period3 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2020, 1, 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStageType, period1),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(2), lifeCycleStageType, period2))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, LifeCycleStageId.FromNumber(2), period3))
.Throws(new LifeCycleCannotHaveOverlappingPeriods()));
}
public void LifeCycleStageDoesNotOverlapWhenChangingItsOwnPeriod(
PublicServiceId publicServiceId,
PublicServiceName publicServiceName,
LifeCycleStageType lifeCycleStageType)
{
// These two periods are ok because they don't overlap
var period1 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2020, 1, 1));
var period2 = new LifeCycleStagePeriod(new ValidFrom(2020, 1, 2), new ValidTo(2021, 1, 1));
// Changing period1 to period3 for '1' will not cause an overlap
var period3 = new LifeCycleStagePeriod(new ValidFrom(2018, 1, 1), new ValidTo(2019, 1, 1));
Assert(new Scenario()
.Given(publicServiceId,
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), lifeCycleStageType, period1),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(2), lifeCycleStageType, period2))
.When(new ChangePeriodOfLifeCycleStage(publicServiceId, LifeCycleStageId.FromNumber(1), period3))
.Then(publicServiceId,
new PeriodOfLifeCycleStageWasChanged(publicServiceId, LifeCycleStageId.FromNumber(1), period3)));
}
public Task ShowsLifeCycleStageWhenLifeCycleStageWasAddedThatOverlapsWithToday()
{
var clockProviderStub = new ClockProviderStub(Today);
var publicServiceId = new PublicServiceId("DVR000000001");
var publicServiceName = new PublicServiceName("Test");
var events = new object[]
{
new PublicServiceWasRegistered(publicServiceId, publicServiceName, PrivateZoneId.Unregistered),
new StageWasAddedToLifeCycle(publicServiceId, LifeCycleStageId.FromNumber(1), LifeCycleStageType.Active, PeriodValidAlways),
};
return(new PublicServiceListProjections(clockProviderStub)
.Scenario()
.Given(events)
.Expect(new PublicServiceListItem
{
Name = publicServiceName,
PublicServiceId = publicServiceId,
CurrentLifeCycleStageType = "Active",
CurrentLifeCycleStageId = 1,
}));
}
public void ImplicitConversionReturnsExpectedResult()
{
int result = LifeCycleStageId.FromNumber(1);
Assert.Equal(1, result);
}
public void NextReturnsExpectedResult()
{
Assert.Equal(LifeCycleStageId.FromNumber(1), LifeCycleStageId.Zero().Next());
Assert.Equal(LifeCycleStageId.FromNumber(3), LifeCycleStageId.FromNumber(2).Next());
}
public void ZeroReturns0()
{
Assert.Equal(0, LifeCycleStageId.Zero());
}
public void CannotCreateFromNumberLowerThan1()
{
Assert.Throws <ArgumentException>(() => LifeCycleStageId.FromNumber(0));
Assert.Throws <ArgumentException>(() => LifeCycleStageId.FromNumber(-1));
}
public void ExplicitConversionReturnsExpectedResult()
{
Assert.Equal(1, (int)LifeCycleStageId.FromNumber(1));
}
