public void WhenExecuteCommandWhichNotExtis_CommandManager_ShouldThrowException()
{
string aliasName = "myalias";
string commandName = "mycommand";
var storedDataService = new StoredDataServiceMock(true);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
var commandDefinition = new AddAliasCommand(storedDataService, instance.Commands);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandNameParameter.GetInvokeName(),
commandName,
commandDefinition.CommandAliasParameter.GetInvokeName(),
aliasName);
Assert.Throws <CommandNotFoundException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithoutOldValueParameter_CommandManager_ShouldThrowException()
{
var path = "mypath";
var newValue = "myOldValue";
var storedDataService = new StoredDataServiceMock();
var fileServiceMock = new FileServiceMock();
var commandDefinition = new ReplaceFileContentCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
path,
commandDefinition.CommandNewValueParameter.GetInvokeName(),
newValue);
Assert.Throws <InvalidParamsException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithRepeatedAliasParameter_CommandManager_ShouldThrowException()
{
string aliasName = "myalias";
string commandName = "mycommand";
string commandNamespace = "name.space";
string commandDescription = "description";
var storedDataService = new StoredDataServiceMock(true);
var mockCommand = new CommandMock(commandNamespace, commandName, commandDescription);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(mockCommand);
var commandDefinition = new AddAliasCommand(storedDataService, instance.Commands);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandNameParameter.GetInvokeName(),
mockCommand.GetInvocationCommandName(),
commandDefinition.CommandAliasParameter.GetInvokeName(),
aliasName);
Assert.Throws <AliasRepeatedException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithRegisteredParameters_CommandManager_ShouldShowList()
{
var path1 = "my.path1";
var path2 = "my.path2";
var name1 = "myname1";
var name2 = "myname2";
var registeredPipelines = new List <RegisteredPipeline>()
{
new RegisteredPipeline(path1, name1, null),
new RegisteredPipeline(path2, name2, null)
};
var storedDataService = new StoredDataServiceMock()
{
GetPipelinesReturn = registeredPipelines
};
var commandDefinition = new ShowPipelinesCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
instance.OnLog += Instance_OnLog;
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
instance.ExecuteInputRequest(inputRequest);
var expected = registeredPipelines.ToDisplayList(
k => $"{k.PipelineName} => {k.Description} located at {k.Path}",
ShowPipelinesCommand.ListHeaderDisplay,
ShowPipelinesCommand.ListFirstCharLine);
var actual = _loggerServiceMock.Logs.First();
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithTemplateNameRepeated_CommandManager_ShouldThrowException()
{
string templatePath = "myPath";
string templateName = "myTemplate";
var storedDataService = new StoredDataServiceMock()
{
ExistsTemplateReturn = true
};
var fileService = new FileServiceMock();
var commandDefinition = new AddTemplateCommand(storedDataService, fileService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
templatePath,
commandDefinition.CommandNameParameter.GetInvokeName(),
templateName);
Assert.Throws <TemplateNameRepeatedException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandCmd_CommandManager_ShouldExecuteCommand()
{
var cmd = "mycommand";
var storedDataService = new StoredDataServiceMock();
var promtpService = new PromptServiceMock();
var commandDefinition = new WindowsCmdCommand(promtpService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandCmdParameter.GetInvokeName(),
cmd);
instance.ExecuteInputRequest(inputRequest);
var expected = cmd;
var actual = promtpService.RunCommandValue;
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithValidTemplate_CommandManager_ShouldThrowException()
{
string templateName = "myTemplate";
var storedDataService = new StoredDataServiceMock()
{
ExistsTemplateReturn = true
};
var commandDefinition = new DeleteTemplateCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandNameParameter.GetInvokeName(),
templateName);
instance.ExecuteInputRequest(inputRequest);
var expected = templateName;
var actual = storedDataService.DeletedTemplate;
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithDirectoryPath_CommandManager_ShouldExecuteMoveDirectoryContent()
{
var mySourcePath = "mypath";
var myDestinationPath = "mypath";
var storedDataService = new StoredDataServiceMock();
var fileServiceMock = new FileServiceMock()
{
ExistsPathReturn = true, IsDirectoryReturn = true
};
var commandDefinition = new MovePathCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandSourcePathParameter.GetInvokeName(),
mySourcePath,
commandDefinition.CommandDestinationFolderParameter.GetInvokeName(),
myDestinationPath);
instance.ExecuteInputRequest(inputRequest);
var expectedSourcePath = mySourcePath;
var expectedDestionationPath = myDestinationPath;
var actualSourcePath = fileServiceMock.MovedSourceFolder;
var actualDestinationPath = fileServiceMock.MovedDestionationFolder;
Assert.Equal(expectedSourcePath, actualSourcePath);
Assert.Equal(expectedDestionationPath, actualDestinationPath);
}
public void WhenExecuteCommandWithValidFolder_CommandManager_ShouldZipDirectory()
{
var path = "myPath";
var storedDataService = new StoredDataServiceMock(false);
var fileServiceMock = new FileServiceMock()
{
IsFileReturn = true
};
var commandDefinition = new UnzipCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
path);
instance.ExecuteInputRequest(inputRequest);
var expected = path;
var actual = fileServiceMock.UnzippedPath;
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithValidPaths_CommandManager_ShouldRename()
{
var newPath = "myNewPath";
var oldPath = "myOldPath";
var storedDataService = new StoredDataServiceMock(false);
var fileServiceMock = new FileServiceMock();
var commandDefinition = new RenameFolderCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathOldFolderParameter.GetInvokeName(),
oldPath,
commandDefinition.CommandPathNewFolderParameter.GetInvokeName(),
newPath);
instance.ExecuteInputRequest(inputRequest);
var expectedOldPath = oldPath;
var expectedONewPath = newPath;
var actualOldPath = fileServiceMock.RenamedOldFolder;
var actualNewPath = fileServiceMock.RenamedNewFolder;
Assert.Equal(expectedOldPath, actualOldPath);
Assert.Equal(expectedONewPath, actualNewPath);
}
public void WhenExecuteCommandWithoutNonExistingSourcePath_CommandManager_ShouldThrowException()
{
var mySourcePath = "mypath";
var myDestinationPath = "mypath";
var storedDataService = new StoredDataServiceMock();
var fileServiceMock = new FileServiceMock()
{
ExistsPathReturn = false
};
var commandDefinition = new MovePathCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandSourcePathParameter.GetInvokeName(),
mySourcePath,
commandDefinition.CommandDestinationFolderParameter.GetInvokeName(),
myDestinationPath);
Assert.Throws <PathNotFoundException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandRegisteredAlias_CommandManager_ShouldReturnZeroAliasMessage()
{
string myAliasDefinition1 = "myalias => mycommand";
string myAliasDefinition2 = "myalias2 => mycommand2";
var aliasList = new List <string>()
{
myAliasDefinition1, myAliasDefinition2
};
var storedDataService = new StoredDataServiceMock(aliasList);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.OnLog += Instance_OnLog;
var commandDefinition = new ShowAliasCommand(storedDataService);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
instance.ExecuteInputRequest(inputRequest);
var expected = aliasList.ToDisplayList(
ShowAliasCommand.HeaderForListingAlias,
ShowAliasCommand.FirstCharacterDefaultForListingAlias);
var actual = _loggerServiceMock.Logs.First();
Assert.Equal(expected, actual);
}
public void WhenExecuteCommand_CommandManager_ShouldAddAlias()
{
string aliasName = "myalias";
string commandName = "mycommand";
string commandNamespace = "name.space";
string commandDescription = "description";
var storedDataService = new StoredDataServiceMock(true);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(new CommandMock(commandNamespace, commandName, commandDescription));
var commandDefinition = new DeleteAliasCommand(storedDataService);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandAliasParameter.GetInvokeName(),
aliasName);
instance.ExecuteInputRequest(inputRequest);
var storedAlias = storedDataService.DeletedAlias;
var actual = storedAlias == aliasName;
Assert.True(actual);
}
public void WhenExecuteCommandWithPipelineNonValidPipelineName_CommandManager_ShouldThrowException()
{
string pipelinePath = "myPath";
string pipelineName = "myPipe NONVALID line";
var storedDataService = new StoredDataServiceMock()
{
ExistsPipelineReturn = false
};
var fileService = new FileServiceMock()
{
ExistsFileReturn = true
};
var commandDefinition = new AddPipelineCommand(storedDataService, fileService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
pipelinePath,
commandDefinition.CommandNameParameter.GetInvokeName(),
pipelineName);
Assert.Throws <InvalidStringFormatException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithParameter_CommandManager_ShouldDeleteParameter()
{
var key = "my.parameter";
var storedDataService = new StoredDataServiceMock()
{
ReturnBoolExistsParameter = true
};
var commandDefinition = new DeleteParameterCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandKeyParameter.GetInvokeName(),
key);
instance.ExecuteInputRequest(inputRequest);
var expected = key;
var actual = storedDataService.DeletedParameter;
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithAlreadyRegisteredParameter_CommandManager_ShouldThrowException()
{
string key = "my.param";
string value = "my value";
var storedDataService = new StoredDataServiceMock()
{
ReturnBoolExistsParameter = true
};
var commandDefinition = new AddParameterCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandKeyParameter.GetInvokeName(),
key,
commandDefinition.CommandValueParameter.GetInvokeName(),
value);
Assert.Throws <ParameterRepeatedException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandKeyAndValue_CommandManager_ShouldCreateParameter()
{
string key = "my.param";
string value = "my value";
var storedDataService = new StoredDataServiceMock()
{
ReturnBoolExistsParameter = false
};
var commandDefinition = new AddParameterCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandKeyParameter.GetInvokeName(),
key,
commandDefinition.CommandValueParameter.GetInvokeName(),
value);
instance.ExecuteInputRequest(inputRequest);
var expectedKey = key;
var actualKey = storedDataService.AddedParameterKey;
Assert.Equal(expectedKey, actualKey);
var expectedValue = value;
var actualValue = storedDataService.AddedParameterValue;
Assert.Equal(expectedValue, actualValue);
}
public void WhenExecuteCommand_AddWPFControlCommand_ShouldGenerateFiles()
{
var controllerReplaced1 = "ControllerPathContent";
var viewModelReplaced2 = "ViewModelPathContent";
var ViewReplaced3 = "ViewPathContent";
var className = "MyClass";
var storedDataService = new StoredDataServiceMock(false);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
var fileService = new FileServiceMock();
var replacementParameter = new Dictionary <string, string>();
replacementParameter["ClassName"] = className;
var templateService = new TemplateReplacementServiceMock()
{
ReturnParameters = replacementParameter,
ReturnedContents = new List <string>()
{
controllerReplaced1,
viewModelReplaced2,
ViewReplaced3
}
};
var commandDefinition = new AddWPFUserControlCommand(fileService, templateService);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
instance.ExecuteInputRequest(inputRequest);
var expectedPath1 = controllerReplaced1;
var actualPath1 = fileService.FilesWritten[0];
var expectedPath2 = viewModelReplaced2;
var actualPath2 = fileService.FilesWritten[1];
var expectedPath3 = ViewReplaced3;
var actualPath3 = fileService.FilesWritten[2];
Assert.Equal(expectedPath1, actualPath1);
Assert.Equal(expectedPath2, actualPath2);
Assert.Equal(expectedPath3, actualPath3);
}
public void WhenExecuteCommandWithoutCommandKey_CommandManager_ShouldThrowException()
{
var storedDataService = new StoredDataServiceMock();
var commandDefinition = new DeleteParameterCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
Assert.Throws <InvalidParamsException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithoutNewPathParameter_CommandManager_ShouldThrowException()
{
var oldPath = "myOldPath";
var storedDataService = new StoredDataServiceMock(false);
var fileServiceMock = new FileServiceMock();
var commandDefinition = new RenameFolderCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathOldFolderParameter.GetInvokeName(),
oldPath);
Assert.Throws <InvalidParamsException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithNoRegisteredAlias_CommandManager_ShouldReturnZeroAliasMessage()
{
var storedDataService = new StoredDataServiceMock(new List <string>());
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.OnLog += Instance_OnLog;
var commandDefinition = new ShowAliasCommand(storedDataService);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
instance.ExecuteInputRequest(inputRequest);
var expected = ShowAliasCommand.ZeroRegisteredMessage;
var actual = _loggerServiceMock.Logs.First();
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandText_CommandManager_ShouldLogText()
{
var cmd = "hellomoto";
var storedDataService = new StoredDataServiceMock();
var commandDefinition = new EchoCommand();
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
instance.OnLog += Instance_OnLog;
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandTextParameter.GetInvokeName(),
cmd);
instance.ExecuteInputRequest(inputRequest);
var expected = cmd;
var actual = _loggerServiceMock.Logs.First();
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithoutCommandParameter_CommandManager_ShouldThrowException()
{
string aliasName = "myalias";
var storedDataService = new StoredDataServiceMock(false);
var registeredCommands = new List <CommandBase>();
var commandDefinition = new AddAliasCommand(storedDataService, registeredCommands);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandAliasParameter.GetInvokeName(),
aliasName);
Assert.Throws <InvalidParamsException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithoutPathParameter_CommandManager_ShouldThrowException()
{
string pipelineName = "myPipeline";
var storedDataService = new StoredDataServiceMock();
var fileService = new FileServiceMock();
var commandDefinition = new AddPipelineCommand(storedDataService, fileService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandNameParameter.GetInvokeName(),
pipelineName);
Assert.Throws <InvalidParamsException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithNonExistingAliasParameter_CommandManager_ShouldThrowException()
{
string aliasName = "myalias";
var storedDataService = new StoredDataServiceMock(false);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
var commandDefinition = new DeleteAliasCommand(storedDataService);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandAliasParameter.GetInvokeName(),
aliasName);
Assert.Throws <AliasNotFoundException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithTemplateNonExistingTemplate_CommandManager_ShouldThrowException()
{
string templateName = "myTemplate";
var storedDataService = new StoredDataServiceMock()
{
ExistsTemplateReturn = false
};
var commandDefinition = new DeleteTemplateCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandNameParameter.GetInvokeName(),
templateName);
Assert.Throws <TemplateNotFoundException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithoutQuestion_CommandManager_ShouldThrowException()
{
var storedDataService = new StoredDataServiceMock();
var consoleServiceMock = new ConsoleServiceMock();
var commandDefinition = new ConfirmCommand();
commandDefinition.ConsoleService = consoleServiceMock;
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
Assert.Throws <InvalidParamsException>(() =>
{
instance.ExecuteInputRequest(inputRequest, new List <string>()
{
});
});
}
public void WhenExecuteCommandWithRegisteredParameters_CommandManager_ShouldShowList()
{
var key1 = "my.pram1";
var key2 = "my.pram2";
var value1 = "my val 1";
var value2 = "my val 2";
var pair1 = $"{key1} => {value1}";
var pair2 = $"{key2} => {value2}";
var listed = new List <string>()
{
pair1, pair2
};
var storedDataService = new StoredDataServiceMock()
{
ParametersWithValueForReturn = listed
};
var commandDefinition = new ShowParametersCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
instance.OnLog += Instance_OnLog;
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
instance.ExecuteInputRequest(inputRequest);
var expected = listed.ToDisplayList(
ShowParametersCommand.ParameterListHeaderDisplay,
ShowParametersCommand.ParameterListFirstCharLine);
var actual = _loggerServiceMock.Logs.First();
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithValidParameters_CommandManager_ShouldAddPipeline()
{
string pipelinePath = "myPath";
string pipelineName = "myPipeline";
var storedDataService = new StoredDataServiceMock()
{
ExistsPipelineReturn = false
};
var fileService = new FileServiceMock()
{
ExistsFileReturn = true
};
var commandDefinition = new AddPipelineCommand(storedDataService, fileService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
pipelinePath,
commandDefinition.CommandNameParameter.GetInvokeName(),
pipelineName);
instance.ExecuteInputRequest(inputRequest);
var expectedPath = pipelinePath;
var actualPath = storedDataService.AddedPipelinePath;
Assert.Equal(expectedPath, actualPath);
var expectedName = pipelineName;
var actualName = storedDataService.AddedPipelineName;
Assert.Equal(expectedName, actualName);
}
public void WhenExecuteCommandWithInvalidFile_CommandManager_ShouldThrowException()
{
var path = "myPath";
var storedDataService = new StoredDataServiceMock(false);
var fileServiceMock = new FileServiceMock()
{
IsFileReturn = false
};
var commandDefinition = new UnzipCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
path);
Assert.Throws <InvalidZipFileException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
