public void itShouldCallUndoOnCommandsThatRanOnly()
{
var commands = new List <BaseCommand>();
var undoableCommand1 = new MockUndoableCommand();
commands.Add(undoableCommand1);
var failingCmd = new MockFailingCommand();
commands.Add(failingCmd);
var undoableCommand2 = new MockUndoableCommand();
commands.Add(undoableCommand2);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
Assert.AreEqual(1, runner.Reports
.Where(r => r.Reporter.Id == undoableCommand1.Id && r.ReportType.IsUndoReport())
.Count());
Assert.AreEqual(1, runner.Reports
.Where(r => r.Reporter.Id == failingCmd.Id && r.ReportType.IsUndoReport())
.Count());
Assert.AreEqual(0, runner.Reports
.Where(r => r.Reporter.Id == undoableCommand2.Id && r.ReportType.IsUndoReport())
.Count());
}
public void AddCommandSuccessfully()
{
var fakeCommand = new Mock <ICommand>();
var commandsRunner = new CommandsRunner();
commandsRunner.AddCommand("FakeCommands", fakeCommand.Object);
}
public void itShouldCallCleanupOnFILOBasis()
{
var commands = new List <BaseCommand>();
var command1 = new MockCommandWithCleanup();
commands.Add(command1);
var command2 = new MockCommandWithCleanup();
commands.Add(command2);
var failingCmd = new MockFailingCommand();
commands.Add(failingCmd);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
var firstCommandCleanupReport = runner.Reports.First(r => r.ReportType.IsCleanupReport() &&
r.Reporter.Id == command1.Id);
var latestCleanupReportTimestamp = runner.Reports.Max(r => r.ReportedOn);
var earliestCleanupReport = runner.Reports.Where(r => r.ReportType.IsCleanupReport())
.OrderBy(r => r.ReportedOn)
.First();
Assert.IsTrue(firstCommandCleanupReport.ReportedOn > earliestCleanupReport.ReportedOn);
Assert.AreEqual(firstCommandCleanupReport.ReportedOn, latestCleanupReportTimestamp);
}
public void AddSameCommandMoreThanOnceThrowsException()
{
var fakeCommand = new Mock <ICommand>();
var commandsRunner = new CommandsRunner();
commandsRunner.AddCommand("FakeCommand", fakeCommand.Object);
commandsRunner.AddCommand("FakeCommand", fakeCommand.Object);
}
public bool RunPreflight(List <CommandConfiguration> commandsConfiguration)
{
var commandsBuilder = new CommandsBuilder(commandsConfiguration);
var commands = commandsBuilder.BuildCommands();
_commandsRunner = new CommandsRunner(commands);
_commandsRunner.OnReportSent += CommandsRunner_OnReportSent;
DidCommandsSucceed = _commandsRunner.RunPreflight();
LastRunElapsedTime = _commandsRunner.LastRunElapsedTime;
return(DidCommandsSucceed);
}
public void itShouldBeResilientWhenIsUndoableThrowException()
{
var commands = new List <BaseCommand>();
commands.Add(new MockIsUndoableThrowingExceptionCommand());
commands.Add(new MockFailingCommand());
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
}
public void itShouldReturnFalseWhenThereAreErrors()
{
var failingCmd = new MockFailingCommand();
var commands = new List <BaseCommand>();
commands.Add(failingCmd);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
}
public void itShouldReturnTrueWhenThereAreNoErrors()
{
var successfulCmd = new MockSucceedingCommand();
var commands = new List <BaseCommand>();
commands.Add(successfulCmd);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsTrue(result);
Assert.AreEqual(result, !runner.HasError);
}
public void RunCommandSuccessfully()
{
var commandsRunner = new CommandsRunner();
var fakeCommand = new Mock <ICommand>();
fakeCommand.Setup(x => x.Execute(null)).Callback(() =>
{
Assert.IsTrue(true);
});
commandsRunner.AddCommand("FakeCommand", fakeCommand.Object);
commandsRunner.RunCommand("FakeCommand");
}
public void itShouldCallCleanupOfInvokedCommandsOnSuccess()
{
var command1 = new MockCommandWithCleanup();
var commands = new List <BaseCommand>();
commands.Add(command1);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsTrue(result);
Assert.IsTrue(runner.Reports.Any(r => r.ReportType.IsCleanupReport() && r.Reporter.Id == command1.Id));
}
public override void Execute(params string[] parameters)
{
// Read all the file before we execute the commands,
// the handling may take along time and we don't want
// to keep the stream active for too long
var commands = File.ReadAllLines(GetPath(parameters)).ToList();
commands.ForEach(command =>
{
Console.WriteLine("Executing \"{0}\"", command);
CommandsRunner.GetInstance().HandleCommand(command);
});
}
public void itShouldNotCallUndoWhenThereAreNoErrors()
{
var successfulCmd = new MockSucceedingCommand();
var commands = new List <BaseCommand>();
commands.Add(successfulCmd);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsTrue(result);
Assert.IsTrue(!runner.Reports.Any(r => r.ReportType.IsUndoReport()));
}
public void RunCommandSuccessfullyWithParameters()
{
var commandsRunner = new CommandsRunner();
var fakeCommand = new Mock <ICommand>();
var args = "command args";
fakeCommand.Setup(x => x.Execute(args)).Callback((string receivedArgs) =>
{
Assert.AreEqual(args, receivedArgs);
});
commandsRunner.AddCommand("FakeCommand", fakeCommand.Object);
commandsRunner.RunCommand("FakeCommand - " + args);
}
public void itShouldBeResilientWhenDoOrUndoThrowsException()
{
var commands = new List <BaseCommand>();
var doThrowingExceptionCommand = new MockDoAndUndoThrowingExceptionCommand();
commands.Add(doThrowingExceptionCommand);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
// Implied assertion: No exceptions raised.
}
public void itShouldHandleExceptionsDuringCleanupButNotAffectOverallOutcome()
{
var commands = new List <BaseCommand>();
var command1 = new MockCommandWithCleanup();
commands.Add(command1);
var command2 = new MockCommandWithCleanupThrowingException();
commands.Add(command2);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsTrue(result);
}
public bool Run()
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(_commandsConfigFile);
var commandsConfigurationSource = new CommandsConfigurationXmlSource(xmlDoc);
var commandsConfiguration = commandsConfigurationSource.GetCommandConfigurations();
var commandsBuilder = new CommandsBuilder(commandsConfiguration);
var commands = commandsBuilder.BuildCommands();
var commandsRunner = new CommandsRunner(commands);
commandsRunner.OnReportSent += CommandsRunner_OnReportSent;
return(commandsRunner.Run());
}
public void itShouldReturnFalseIfAtLeastOneFailed()
{
var cmdSucceeding1 = new MockCommandPreflightSucceeding();
var cmdFailing = new MockCommandPreflightFailing();
var cmdSucceeding2 = new MockCommandPreflightSucceeding();
var commands = new List <BaseCommand>();
commands.Add(cmdSucceeding1);
commands.Add(cmdFailing);
commands.Add(cmdSucceeding2);
var runner = new CommandsRunner(commands);
var result = runner.RunPreflight();
Assert.IsFalse(result);
}
public void itShouldRunEnabledCommandsOnly()
{
var commands = new List <BaseCommand>();
var command1 = new MockSucceedingCommand();
command1.Enabled = true;
commands.Add(command1);
var command2 = new MockSucceedingCommand();
command2.Enabled = false;
commands.Add(command2);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsTrue(result);
Assert.IsTrue(runner.WasCommandStarted(command1));
Assert.IsFalse(runner.WasCommandStarted(command2));
}
public override void Execute(params string[] parameters)
{
Console.WriteLine("The supported commands are:");
foreach (var commandsDictionaryValue in CommandsRunner.GetInstance().CommandsDictionary.Values)
{
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine(commandsDictionaryValue.CommandName);
Console.ResetColor();
Console.WriteLine(commandsDictionaryValue.Description);
if (commandsDictionaryValue.Parameters.Any())
{
Console.WriteLine("Parameters:");
commandsDictionaryValue.Parameters.ForEach(parameter =>
{
Console.WriteLine("- {0} {1}", parameter.Index, parameter.Name);
});
}
}
}
public void itShouldSupportCancellation()
{
var commands = new List <BaseCommand>();
var command1 = new MockSucceedingCommand();
commands.Add(command1);
var command2 = new MockSleepingCommand(2000);
commands.Add(command2);
var command3 = new MockSucceedingCommand();
commands.Add(command3);
var runner = new CommandsRunner(commands);
bool result = true;
ThreadStart starter = new ThreadStart(() => {
result = runner.Run();
});
var thread = new Thread(starter);
thread.Start();
// Sleep to give time for command1 to succeed.
Thread.Sleep(500);
// Cancel before command2 completes
runner.Cancel();
thread.Join();
// Cancelled means failed result
Assert.IsFalse(result);
Assert.IsTrue(runner.WasCommandStarted(command1));
// Cancellation should trigger Undo
Assert.IsTrue(runner.Reports.Any(r => r.Reporter == command1 && r.ReportType.IsUndoReport()));
Assert.IsTrue(runner.WasCommandStarted(command2));
// Cancellation should not run next command in the chain.
Assert.IsFalse(runner.WasCommandStarted(command3));
}
public void itShouldRunOnlyCommandsWithHasPreflightCheckSet()
{
var cmdSucceeding1 = new MockCommandPreflightSucceeding();
var cmdPreflightCheckFlagNotSet = new MockCommandHasPreflightCheckButFlagNotSet();
var cmdSucceeding2 = new MockCommandPreflightSucceeding();
var commands = new List <BaseCommand>();
commands.Add(cmdSucceeding1);
commands.Add(cmdPreflightCheckFlagNotSet);
commands.Add(cmdSucceeding2);
var runner = new CommandsRunner(commands);
var result = runner.RunPreflight();
Assert.IsTrue(result);
Assert.IsTrue(cmdSucceeding1.PreflightCheckRan);
Assert.IsFalse(cmdPreflightCheckFlagNotSet.PreflightCheckRan);
Assert.IsTrue(cmdSucceeding2.PreflightCheckRan);
}
public void itShouldReturnFalseOnUnhandledExceptions()
{
var cmdSucceeding1 = new MockCommandPreflightSucceeding();
var cmdFailing = new MockCommandThrowingExceptionAtPreflightCheck();
var cmdSucceeding2 = new MockCommandPreflightSucceeding();
var commands = new List <BaseCommand>();
commands.Add(cmdSucceeding1);
commands.Add(cmdFailing);
commands.Add(cmdSucceeding2);
var runner = new CommandsRunner(commands);
var result = runner.RunPreflight();
Assert.IsFalse(result);
Assert.IsTrue(cmdSucceeding1.PreflightCheckRan);
Assert.IsTrue(cmdFailing.PreflightCheckRan);
Assert.IsTrue(cmdSucceeding2.PreflightCheckRan);
}
public void itShouldRunAllChecksEvenIfOneFailedMidway()
{
var cmdSucceeding1 = new MockCommandPreflightSucceeding();
var cmdFailing = new MockCommandPreflightFailing();
var cmdSucceeding2 = new MockCommandPreflightSucceeding();
var commands = new List <BaseCommand>();
commands.Add(cmdSucceeding1);
commands.Add(cmdFailing);
commands.Add(cmdSucceeding2);
var runner = new CommandsRunner(commands);
var result = runner.RunPreflight();
Assert.IsFalse(result);
Assert.IsTrue(cmdSucceeding1.PreflightCheckRan);
Assert.IsTrue(cmdFailing.PreflightCheckRan);
Assert.IsTrue(cmdSucceeding2.PreflightCheckRan);
}
public void itShouldDiscontinueWhenCommandFails()
{
var commands = new List <BaseCommand>();
var successfulCmd1 = new MockSucceedingCommand();
commands.Add(successfulCmd1);
var failingCmd = new MockFailingCommand();
commands.Add(failingCmd);
var successfulCmd2 = new MockSucceedingCommand();
commands.Add(successfulCmd2);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
// There should be no report from successfulCmd2 whatsoever because of failingCmd.
Assert.IsFalse(runner.WasCommandStarted(successfulCmd2));
}
public void itShouldBeIdempotent()
{
var successfulCmd = new MockSucceedingCommand();
var commands = new List <BaseCommand>();
commands.Add(successfulCmd);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsTrue(result);
Assert.AreEqual(result, !runner.HasError);
var firstRunReportCount = runner.Reports.Count();
result = runner.Run();
Assert.IsTrue(result);
Assert.AreEqual(result, !runner.HasError);
var secondRunReportCount = runner.Reports.Count();
Assert.AreEqual(firstRunReportCount, secondRunReportCount);
}
public void itShouldContinueUndoEvenWhenOneUndoFails()
{
var commands = new List <BaseCommand>();
var undoableCommand1 = new MockUndoableCommand();
commands.Add(undoableCommand1);
var undoableCommand2 = new MockUndoThrowingExceptionCommand();
commands.Add(undoableCommand2);
var failingCmd = new MockFailingCommand();
commands.Add(failingCmd);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
Assert.AreEqual(3, runner.Reports.Where(r => r.ReportType.IsUndoReport()).Count());
}
public void itShouldSetWasCommandStartedOnRanCommandsOnly()
{
var commands = new List <BaseCommand>();
var command1 = new MockSucceedingCommand();
commands.Add(command1);
var failingCmd = new MockFailingCommand();
commands.Add(failingCmd);
var command2 = new MockUndoableCommand();
commands.Add(command2);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
Assert.IsTrue(runner.WasCommandStarted(command1));
Assert.IsTrue(runner.WasCommandStarted(failingCmd));
Assert.IsFalse(runner.WasCommandStarted(command2));
}
public void itShouldCallCleanupOfInvokedCommandsOnly()
{
var commands = new List <BaseCommand>();
var command1 = new MockCommandWithCleanup();
commands.Add(command1);
var command2 = new MockFailingCommand();
commands.Add(command2);
var command3 = new MockCommandWithCleanup();
commands.Add(command3);
var runner = new CommandsRunner(commands);
var result = runner.Run();
Assert.IsFalse(result);
Assert.IsTrue(runner.WasCommandStarted(command1));
Assert.IsTrue(runner.Reports.Any(r => r.ReportType.IsCleanupReport() && r.Reporter.Id == command1.Id));
Assert.IsTrue(!runner.WasCommandStarted(command3));
Assert.IsFalse(runner.Reports.Any(r => r.ReportType.IsCleanupReport() && r.Reporter.Id == command3.Id));
}
public void RunCommandWithNullArgumentStringThrowsException()
{
var commandsRunner = new CommandsRunner();
commandsRunner.RunCommand(null);
}
public void RunCommandWithEmptyStringThrowsException()
{
var commandsRunner = new CommandsRunner();
commandsRunner.RunCommand("");
}
