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>()); }