public async Task CallsAllMatchingOrchestrators(CauseAnarchyType?firstCanHandle, CauseAnarchyType?secondCanHandle, CauseAnarchyType?thirdCanHandle)
{
//arrange
var canHandleStates = new[] { firstCanHandle, secondCanHandle, thirdCanHandle };
var orchestrators = canHandleStates.Select(state =>
GetMockOrchestratorWithAnarchyTypeAndHandlingState(state != null, state ?? CauseAnarchyType.Passive))
.ToList();
var sut = new AnarchyManagerNew(orchestrators);
var context = Get.CustomBuilderFor.MockHttpContext.Build();
var next = Substitute.For <RequestDelegate>();
//act
await sut.HandleRequest(context, next);
//assert
for (var i = 0; i < canHandleStates.Length; i++)
{
var shouldHaveHandled = canHandleStates[i] != null;
if (shouldHaveHandled)
{
await orchestrators[i].Received(1)
.HandleRequest(context, next);
}
else
{
await orchestrators[i].DidNotReceive()
.HandleRequest(Arg.Any <HttpContext>(), Arg.Any <RequestDelegate>());
}
}
}
public void SelectsFirstMatchingOrchestrator(string firstActionName, string secondActionName, int repeatCount)
{
//arrange
var orchestrator1 = Substitute.For <IActionOrchestrator>();
var orchestrator2 = Substitute.For <IActionOrchestrator>();
var firstAction = Substitute.For <ICauseAnarchy>();
firstAction.Name.Returns(firstActionName);
var secondAction = Substitute.For <ICauseAnarchy>();
secondAction.Name.Returns(secondActionName);
orchestrator1.AnarchyAction.Returns(firstAction);
orchestrator1.ExecutionSchedule.Returns(new Schedule {
RepeatCount = 1
});
orchestrator2.AnarchyAction.Returns(secondAction);
orchestrator2.ExecutionSchedule.Returns(new Schedule {
RepeatCount = 2
});
var sut = new AnarchyManagerNew(new[] { orchestrator1, orchestrator2 });
//act
var result = sut.GetScheduleFromActionOrchestrator("firstActionName");
//assert
result.RepeatCount.Should().Be(repeatCount);
}
public async Task AlwaysCallsAlterResponseOrchestratorLast()
{
//arrange
var context = Get.CustomBuilderFor.MockHttpContext.Build();
var next = Substitute.For <RequestDelegate>();
DateTime?alterResponseCalledAt = null;
DateTime?passiveResponseCalledAt = null;
var passiveOrchestrator = GetMockOrchestratorWithAnarchyTypeAndHandlingState(true, CauseAnarchyType.Passive);
passiveOrchestrator.HandleRequest(context, next)
.Returns(Task.Delay(100))
.AndDoes(_ => passiveResponseCalledAt = DateTime.Now);
var alterResponseOrchestrator = GetMockOrchestratorWithAnarchyTypeAndHandlingState(true, CauseAnarchyType.AlterResponse);
alterResponseOrchestrator.HandleRequest(context, next)
.Returns(Task.Delay(100))
.AndDoes(_ => alterResponseCalledAt = DateTime.Now);
var sut = new AnarchyManagerNew(new [] { alterResponseOrchestrator, passiveOrchestrator });
//act
await sut.HandleRequest(context, next);
//assert
alterResponseCalledAt.Value.Should().BeAfter(passiveResponseCalledAt.Value);
}
public void OnlySchedulableActionsAreStarted()
{
//arrange
var orchestrators = new[]
{
Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithSchedule.Build(),
Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithUnschedulableAction.Build(),
Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithSchedule.Build(),
};
var sut = new AnarchyManagerNew(orchestrators);
//act
sut.StartAllSchedules();
//assert
foreach (var orchestrator in orchestrators)
{
if (orchestrator.AnarchyAction is ICauseScheduledAnarchy)
{
orchestrator.Received(1).Start();
}
else
{
orchestrator.DidNotReceive().Start();
}
}
}
public void NoOrchestrators()
{
//arrange
var sut = new AnarchyManagerNew(new IActionOrchestrator[] { });
//act/assert
Assert.DoesNotThrow(() => sut.StartAllSchedules());
}
public void ReturnsCorrectlyWithoutActions()
{
//arrange
var sut = new AnarchyManagerNew(new IActionOrchestrator[0]);
//act
var result = sut.GetAllSchedulesFromOrchestrators();
//assert
result.Count().Should().Be(0);
}
public void OnlyReturnsSchedulableActionOrchestrators(int scheduled, int scheduledButEmpty, int unscheduled, int expectedCount)
{
//arrange
var orchestrators = GetTestActionOrchestratorsOfType(scheduled, scheduledButEmpty, unscheduled);
var sut = new AnarchyManagerNew(orchestrators);
//act
var result = sut.GetAllSchedulesFromOrchestrators();
//assert
result.Count().Should().Be(expectedCount);
}
public void DoesNotReturnUnschedulableActionOrchestrators()
{
//arrange
var orchestrators = GetTestActionOrchestratorsOfType(0, 0, 1);
var sut = new AnarchyManagerNew(orchestrators);
//act
var result = sut.GetAllSchedulesFromOrchestrators();
//assert
result.Should().BeEmpty();
}
public void ReturnsSchedulableButEmptyActionOrchestrators()
{
//arrange
var orchestrators = GetTestActionOrchestratorsOfType(0, 1, 0);
var sut = new AnarchyManagerNew(orchestrators);
//act
var result = sut.GetAllSchedulesFromOrchestrators();
//assert
result.Count().Should().Be(1);
}
public void PopulatesScheduleCorrectly()
{
//arrange
var orchestrators = GetTestActionOrchestratorsOfType(1, 1, 0);
var sut = new AnarchyManagerNew(orchestrators);
//act
var result = sut.GetAllSchedulesFromOrchestrators();
//assert
result.ToArray()[0].Schedule.Should().Be(orchestrators[0].ExecutionSchedule);
result.ToArray()[1].Schedule.Should().Be(orchestrators[1].ExecutionSchedule);
}
public void MatchingOrchestrator_ValidNewSchedule(string anarchyType)
{
//arrange
var orchestrator = Get.MotherFor.MockAnarchyActionOrchestrator
.OrchestratorWithScheduleNamed("testAnarchyType").Build();
var sut = new AnarchyManagerNew(new [] { orchestrator });
//act
sut.StopAction(anarchyType);
//assert
orchestrator.Received(1).Stop();
}
public void MatchingOrchestrator(string anarchyType)
{
//arrange
var orchestrator = Get.MotherFor.MockAnarchyActionOrchestrator
.OrchestratorWithScheduleNamed("testAnarchyType").Build();
var sut = new AnarchyManagerNew(new [] { orchestrator });
//act
sut.UpdateAction(anarchyType, FakeUpdatePayload);
//assert
orchestrator.Received(1).UpdateAction(FakeUpdatePayload);
}
public void NoMatchingOrchestrator(string anarchyType)
{
//arrange
var orchestrator = Get.MotherFor.MockAnarchyActionOrchestrator
.OrchestratorWithScheduleNamed("testAnarchyType").Build();
var sut = new AnarchyManagerNew(new [] { orchestrator });
//act
var exception = Assert.Catch(() => sut.StopAction(anarchyType));
//assert
exception.Should().BeOfType <AnarchyActionNotFoundException>();
orchestrator.Received(0).Stop();
}
public void SelectsFirstMatchingOrchestrator(string firstActionName, string secondActionName, int firstCount, int secondCount)
{
//arrange
var orchestrator1 = Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithScheduleNamed(firstActionName).Build();
var orchestrator2 = Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithScheduleNamed(secondActionName).Build();
var sut = new AnarchyManagerNew(new [] { orchestrator1, orchestrator2 });
//act
sut.AssignTargetPattern("firstActionName", ".*");
//assert
orchestrator1.Received(firstCount).ForTargetPattern(".*");
orchestrator2.Received(secondCount).ForTargetPattern(".*");
}
public void MatchingOrchestrator(string anarchyType)
{
//arrange
var orchestrator = Get.MotherFor
.MockAnarchyActionOrchestrator
.OrchestratorWithScheduleNamed("testAnarchyType").Build();
var sut = new AnarchyManagerNew(new [] { orchestrator });
//act
sut.AssignTargetPattern(anarchyType, ".*");
//assert
orchestrator.Received(1).ForTargetPattern(".*");
}
public void CallsAllOrchestrators()
{
//arrange
var orchestrator1 = Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithoutSchedule.Build();
var orchestrator2 = Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithSchedule.Build();
var sut = new AnarchyManagerNew(new [] { orchestrator1, orchestrator2 });
//act
sut.StopAllActions();
//assert
orchestrator1.Received(1).Stop();
orchestrator2.Received(1).Stop();
}
public async Task NoMatchingOrchestrator(CauseAnarchyType causeAnarchyType)
{
//arrange
var orchestrator = GetMockOrchestratorWithAnarchyTypeAndHandlingState(false, causeAnarchyType);
var sut = new AnarchyManagerNew(new[] { orchestrator });
var context = Get.CustomBuilderFor.MockHttpContext.Build();
var next = Substitute.For <RequestDelegate>();
//act
await sut.HandleRequest(context, next);
//assert
await orchestrator.Received(0).HandleRequest(context, next);
}
public void MatchingOrchestrator_ScheduleNotExists()
{
//arrange
var orchestrator = Substitute.For <IActionOrchestrator>();
var action = Substitute.For <ICauseAnarchy>();
action.Name.Returns("testAnarchyType");
orchestrator.AnarchyAction.Returns(action);
orchestrator.ExecutionSchedule.Returns((Schedule)null);
var sut = new AnarchyManagerNew(new[] { orchestrator });
//act
var result = sut.GetScheduleFromActionOrchestrator("testAnarchyType");
//assert
result.Should().BeNull();
}
public void MatchingOrchestrator_ValidNewSchedule(string anarchyType)
{
//arrange
var schedule = new Schedule();
var orchestrator = Substitute.For <IActionOrchestrator>();
var action = Substitute.For <ICauseAnarchy>();
action.Name.Returns("testAnarchyType");
orchestrator.AnarchyAction.Returns(action);
var sut = new AnarchyManagerNew(new [] { orchestrator });
//act
sut.AssignScheduleToActionOrchestrator(anarchyType, schedule, false);
//assert
orchestrator.Received(1).AssociateSchedule(schedule);
}
public void NoMatchingOrchestrator(string anarchyAction)
{
//arrange
var schedule = new Schedule();
var orchestrator = Substitute.For <IActionOrchestrator>();
var action = Substitute.For <ICauseAnarchy>();
action.Name.Returns("testAnarchyType");
orchestrator.AnarchyAction.Returns(action);
orchestrator.ExecutionSchedule.Returns(schedule);
var sut = new AnarchyManagerNew(new[] { orchestrator });
//act
var exception = Assert.Catch(() => sut.GetScheduleFromActionOrchestrator(anarchyAction));
//assert
exception.Should().BeOfType <AnarchyActionNotFoundException>();
}
public void NoMatchingOrchestrator(string anarchyType)
{
//arrange
var schedule = new Schedule();
var orchestrator = Substitute.For <IActionOrchestrator>();
var action = Substitute.For <ICauseAnarchy>();
action.Name.Returns("testAnarchyType");
orchestrator.AnarchyAction.Returns(action);
var sut = new AnarchyManagerNew(new [] { orchestrator });
//act
var exception = Assert.Catch(() => sut.UpdateAction(anarchyType, FakeUpdatePayload));
//assert
exception.Should().BeOfType <AnarchyActionNotFoundException>();
orchestrator.Received(0).UpdateAction(Arg.Any <string>());
}
public void MatchingOrchestrator_ScheduleExists_AllowUpdate()
{
//arrange
var orchestrator = Substitute.For <IActionOrchestrator>();
var action = Substitute.For <ICauseAnarchy>();
action.Name.Returns("testAnarchyType");
orchestrator.ExecutionSchedule.Returns(new Schedule());
orchestrator.AnarchyAction.Returns(action);
var sut = new AnarchyManagerNew(new[] { orchestrator });
var schedule = new Schedule();
//act
sut.AssignScheduleToActionOrchestrator("testAnarchyType", schedule, true);
//assert
orchestrator.Received(1).AssociateSchedule(schedule);
}
public void MatchingOrchestrator_ScheduleExists_DoNotAllowUpdate()
{
//arrange
var orchestrator = Substitute.For <IActionOrchestrator>();
var action = Substitute.For <ICauseAnarchy>();
action.Name.Returns("testAnarchyType");
orchestrator.ExecutionSchedule.Returns(new Schedule());
orchestrator.AnarchyAction.Returns(action);
var sut = new AnarchyManagerNew(new [] { orchestrator });
var schedule = new Schedule();
//act
var exception = Assert.Catch(() => sut.AssignScheduleToActionOrchestrator("testAnarchyType", new Schedule(), false));
//assert
exception.Should().BeOfType <ScheduleExistsException>();
orchestrator.Received(0).AssociateSchedule(schedule);
}
public void NoScheduledOrchestrators()
{
//arrange
var orchestrators = new[]
{
Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithUnschedulableAction.Build(),
Get.MotherFor.MockAnarchyActionOrchestrator.OrchestratorWithUnschedulableAction.Build()
};
var sut = new AnarchyManagerNew(orchestrators);
//act
sut.StartAllSchedules();
//assert
foreach (var orchestrator in orchestrators)
{
orchestrator.DidNotReceive().Start();
}
}
public void MatchingOrchestrator(string anarchyType, int?durationSecs)
{
//arrange
var orchestrator = Get.MotherFor
.MockAnarchyActionOrchestrator
.OrchestratorWithScheduleNamed("testAnarchyType")
.Build();
var duration = durationSecs.HasValue ?
TimeSpan.FromSeconds(durationSecs.Value) :
(TimeSpan?)null;
var sut = new AnarchyManagerNew(new [] { orchestrator });
//act
sut.TriggerAction(anarchyType, duration);
//assert
orchestrator.Received(1).TriggerOnce(duration);
}
public void SelectsFirstMatchingOrchestrator(string firstActionName, string secondActionName, int firstCount, int secondCount)
{
//arrange
var schedule = new Schedule();
var orchestrators = Get.CustomBuilderFor.MockAnarchyActionOrchestrators
.WithActionsNamed(firstActionName, secondActionName)
.WithSchedules(schedule, schedule)
.Build()
.Select(orchestratorBuilder => orchestratorBuilder.Build())
.ToList();
var sut = new AnarchyManagerNew(orchestrators);
//act
sut.TriggerAction("firstActionName", TimeSpan.FromSeconds(1));
//assert
orchestrators[0].Received(firstCount).TriggerOnce(Arg.Any <TimeSpan?>());
orchestrators[1].Received(secondCount).TriggerOnce(Arg.Any <TimeSpan?>());
}
public void OnlyAllowsASingleHandlingActionOrchestratorOfTypeAlterResponse()
{
//arrange
var actionOrchestrators = new[]
{
GetMockOrchestratorWithAnarchyTypeAndHandlingState(true, CauseAnarchyType.AlterResponse),
GetMockOrchestratorWithAnarchyTypeAndHandlingState(true, CauseAnarchyType.Passive),
GetMockOrchestratorWithAnarchyTypeAndHandlingState(true, CauseAnarchyType.AlterResponse)
};
var sut = new AnarchyManagerNew(actionOrchestrators);
var context = Get.CustomBuilderFor.MockHttpContext.Build();
var next = Substitute.For <RequestDelegate>();
//act
var exception = Assert.CatchAsync(async() => await sut.HandleRequest(context, next));
//assert
exception.Should().BeOfType <MultipleResponseAlteringActionsEnabledException>();
}
public void SelectsFirstMatchingOrchestrator(string firstActionName, string secondActionName, int firstCount, int secondCount)
{
//arrange
var schedule = new Schedule();
var orchestrator1 = Substitute.For <IActionOrchestrator>();
var orchestrator2 = Substitute.For <IActionOrchestrator>();
var firstAction = Substitute.For <ICauseAnarchy>();
firstAction.Name.Returns(firstActionName);
var secondAction = Substitute.For <ICauseAnarchy>();
secondAction.Name.Returns(secondActionName);
orchestrator1.AnarchyAction.Returns(firstAction);
orchestrator2.AnarchyAction.Returns(secondAction);
var sut = new AnarchyManagerNew(new [] { orchestrator1, orchestrator2 });
//act
sut.AssignScheduleToActionOrchestrator("firstActionName", schedule, false);
//assert
orchestrator1.Received(firstCount).AssociateSchedule(Arg.Any <Schedule>());
orchestrator2.Received(secondCount).AssociateSchedule(Arg.Any <Schedule>());
}
