public void GetOptions_returns_expected_omit_xml_declaration_value(bool value)
{
// Arrange
var input = new CommandLineOptions() {
OmitXmlDeclarations = value
};
// Act
var result = _sut.GetOptions(input);
// Assert
Assert.AreEqual(value, result.OmitXmlDeclaration);
}
public void GetOptions_returns_expected_context_visitor_type_names()
{
// Arrange
var value = _autofixture.Create<string>();
var input = new CommandLineOptions() {
ContextVisitorClassNames = value
};
// Act
var result = _sut.GetOptions(input);
// Assert
Assert.AreEqual(value, result.ContextVisitorTypes);
}
public void GetOptions_returns_expected_output_encoding()
{
// Arrange
var value = _autofixture.Create<string>();
var input = new CommandLineOptions() {
OutputEncoding = value
};
// Act
var result = _sut.GetOptions(input);
// Assert
Assert.AreEqual(value, result.OutputEncodingName);
}
private void AddKeywordOptions(CommandLineOptions options, ref IRenderingOptions renderingOptions)
{
if(!String.IsNullOrEmpty(options.KeywordOptions))
{
var keywordOptions = options.KeywordOptions
.Split(KEYWORD_OPTION_SEPARATOR)
.Select(GetKeywordOption);
foreach(var option in keywordOptions)
{
renderingOptions.KeywordOptions.Add(option.Item1, option.Item2);
}
}
}
public void GetOptions_returns_expected_keyword_options()
{
// Arrange
var input = new CommandLineOptions() {
KeywordOptions = "foo=bar;wibble=wobble;spork=splife"
};
// Act
var result = _sut.GetOptions(input);
// Assert
Assert.AreEqual(3, result.KeywordOptions.Count, "Count of keyword options");
Assert.AreEqual("bar", result.KeywordOptions["foo"], "First option as expected");
Assert.AreEqual("wobble", result.KeywordOptions["wibble"], "Second option as expected");
Assert.AreEqual("splife", result.KeywordOptions["spork"], "Third option as expected");
}
public IBatchRenderingOptions GetBatchOptions(CommandLineOptions options)
{
var inputFiles = options.InputPaths.Select(GetInputFile).ToArray();
var useStdin = ReadFromStandardInput(inputFiles);
var ignoredPaths = GetIgnoredPaths(options);
var outputPath = GetOutputPath(options);
var useStdOut = OutputToStdOut(inputFiles, outputPath);
return new BatchRenderingOptions(inputStream: useStdin? Console.OpenStandardInput() : null,
outputStream: useStdOut? Console.OpenStandardOutput() : null,
inputPaths: inputFiles.Where(x => x != null),
outputPath: outputPath,
inputSearchPattern: options.InputFilenamePattern,
outputExtensionOverride: options.OutputFilenameExtension,
ignoredPaths: ignoredPaths,
renderingMode: options.GetRenderingMode());
}
public IRenderingOptions GetOptions(CommandLineOptions options)
{
if(options == null)
{
throw new ArgumentNullException(nameof(options));
}
IRenderingOptions output = new RenderingOptions() {
AddSourceFileAnnotation = options.EnableSourceAnnotation,
OmitXmlDeclaration = options.OmitXmlDeclarations,
ContextVisitorTypes = options.ContextVisitorClassNames,
RenderingContextFactoryType = options.RenderingContextFactoryClassName,
OutputEncodingName = options.OutputEncoding
};
AddKeywordOptions(options, ref output);
return output;
}
private IEnumerable<DirectoryInfo> GetIgnoredPaths(CommandLineOptions options)
{
IEnumerable<DirectoryInfo> output;
if(String.IsNullOrEmpty(options.IgnoredPaths))
{
output = new DirectoryInfo[0];
}
else
{
output = options.IgnoredPaths
.Split(IGNORED_PATH_SEPARATOR)
.Select(x => {
var absolutePath = MakeAbsolutePath(x);
return Directory.Exists(absolutePath)? new DirectoryInfo(absolutePath) : null;
});
}
return output;
}
public void WritesErrorToStdErrAndTerminates_WhenInvalidEncodingSpecified()
{
// Arrange
var optionsFactory = new Mock<IRenderingOptionsFactory>();
optionsFactory
.Setup(x => x.GetOptions(It.IsAny<CommandLineOptions>()))
.Throws<InvalidOutputEncodingException>();
var sut = new Application(renderer: _renderer.Object,
renderingOptionsFactory: optionsFactory.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions();
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: The encoding specified by the --output-encoding argument is invalid.
The encoding (where specified) must be valid encoding 'WebName'. Consult the manual for more information.
";
Assert.AreEqual(expected, errorOutput, "Correct message written");
_terminator.Verify(x => x.Terminate(ApplicationTerminator.ExpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
public void Setup()
{
_autofixture = new Fixture();
_baseDirectory = new DirectoryInfo(System.Environment.CurrentDirectory);
_sut = new BatchRenderingOptionsFactory(_baseDirectory);
_options = new CommandLineOptions();
}
public void WritesErrorToStdErrAndTerminates_WhenBothHtmlAndXmlModesSpecified()
{
// Arrange
var sut = new Application(renderer: _renderer.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions() {
ForceHtmlMode = true,
ForceXmlMode = true,
};
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: The '--html' and '--xml' arguments are mutually exclusive and may not be used together.
Use 'ZptBuilder.exe --help' for help on providing correct arguments, or consult the manual.
";
Assert.AreEqual(expected, errorOutput, "Correct message written");
_terminator.Verify(x => x.Terminate(ApplicationTerminator.ExpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
private string ExerciseSutWithStdErrRedirection(Application sut,
CommandLineOptions options)
{
string errorOutput;
using(var writer = SetupStdErrRedirection())
{
sut.Begin(options);
errorOutput = writer.ToString();
}
return errorOutput;
}
public void WritesErrorToStdErrAndTerminates_WhenTooManyInputsSpecified()
{
// Arrange
var sut = new Application(renderer: _renderer.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions();
_renderer
.Setup(x => x.Render(It.IsAny<IBatchRenderingOptions>(),
It.IsAny<IRenderingOptions>()))
.Throws(new InvalidBatchRenderingOptionsException(_autofixture.Create<string>(),
BatchRenderingFatalErrorType.InputCannotBeBothStreamAndPaths));
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: The inputs must either be a list of paths OR '-' (indicating the use of standard
input), not both. Use 'ZptBuilder.exe --help', or consult the manual.
";
try
{
Assert.That(errorOutput.StartsWith(expected), "Correct message written (only the start of the message)");
}
catch(AssertionException)
{
_logger.Error(errorOutput);
throw;
}
_terminator.Verify(x => x.Terminate(ApplicationTerminator.ExpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
public void WritesErrorToStdErrAndTerminates_WhenUnexpectedErrorOccursDuringRendering()
{
// Arrange
var sut = new Application(renderer: _renderer.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions();
_renderer
.Setup(x => x.Render(It.IsAny<IBatchRenderingOptions>(),
It.IsAny<IRenderingOptions>()))
.Throws<InvalidOperationException>();
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: The application has encountered a fatal unexpected error; please report this as a bug at
https://github.com/csf-dev/ZPT-Sharp
Please include the information below with your bug report
---
";
try
{
Assert.That(errorOutput.StartsWith(expected), "Correct message written (only the start of the message)");
}
catch(AssertionException)
{
_logger.Error(errorOutput);
throw;
}
_terminator.Verify(x => x.Terminate(ApplicationTerminator.UnexpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
public void GetOptions_returns_expected_rendering_context_factory_type_names()
{
// Arrange
var value = _autofixture.Create<string>();
var input = new CommandLineOptions() {
RenderingContextFactoryClassName = value
};
// Act
var result = _sut.GetOptions(input);
// Assert
Assert.AreEqual(value, result.RenderingContextFactoryType);
}
public void WritesErrorToStdErrAndTerminates_WhenInvalidInputFilesAreSpecified()
{
// Arrange
var filename = "FOO BAR";
var batchFactory = new Mock<IBatchRenderingOptionsFactory>();
batchFactory
.Setup(x => x.GetBatchOptions(It.IsAny<CommandLineOptions>()))
.Throws(new InvalidInputPathException() { Path = filename });
var sut = new Application(renderer: _renderer.Object,
batchOptionsFactory: batchFactory.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions();
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: A specified input path is invalid, perhaps it does not exist or you have insufficient permissions to access it?
The problematic path is:FOO BAR
";
Assert.AreEqual(expected, errorOutput, "Correct message written");
_terminator.Verify(x => x.Terminate(ApplicationTerminator.ExpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
public void WritesErrorToStdErrAndTerminates_WhenInvalidKeywordOptionSpecified()
{
// Arrange
var optionname = "FOO BAR";
var optionsFactory = new Mock<IRenderingOptionsFactory>();
optionsFactory
.Setup(x => x.GetOptions(It.IsAny<CommandLineOptions>()))
.Throws(new InvalidKeywordOptionsException() { InvalidOption = optionname });
var sut = new Application(renderer: _renderer.Object,
renderingOptionsFactory: optionsFactory.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions();
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: An option specified using the --keyword-options argument is in an invalid format.
Where specified, options must be in the format 'OPTION1=VALUE1;OPTION2=VALUE2' and so on.
The invalid option is:FOO BAR
";
Assert.AreEqual(expected, errorOutput, "Correct message written");
_terminator.Verify(x => x.Terminate(ApplicationTerminator.ExpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
public void WritesErrorToStdErrAndTerminates_WhenInvalidRenderingContextFactorySpecified()
{
// Arrange
var optionsFactory = new Mock<IRenderingOptionsFactory>();
optionsFactory
.Setup(x => x.GetOptions(It.IsAny<CommandLineOptions>()))
.Throws(new CouldNotCreateRenderingContextFactoryException() { InvalidClassname = _autofixture.Create<string>() });
var sut = new Application(renderer: _renderer.Object,
renderingOptionsFactory: optionsFactory.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions();
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: The type named using the --rendering-context-factory argument could not be instantiated.
Where specified, this type must exist and have a parameterless constructor.
";
Assert.AreEqual(expected, errorOutput, "Correct message written");
_terminator.Verify(x => x.Terminate(ApplicationTerminator.ExpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
public void WritesErrorToStdErrAndTerminates_WhenInvalidOutputPathSpecified()
{
// Arrange
var batchFactory = new Mock<IBatchRenderingOptionsFactory>();
batchFactory
.Setup(x => x.GetBatchOptions(It.IsAny<CommandLineOptions>()))
.Throws(new InvalidOutputPathException());
var sut = new Application(renderer: _renderer.Object,
batchOptionsFactory: batchFactory.Object,
terminator: _terminator.Object);
var options = new CommandLineOptions();
// Act
var errorOutput = ExerciseSutWithStdErrRedirection(sut, options);
// Assert
string expected = @"ERROR: The specified output path is invalid. Where a directory path is specified, the directory must exist.
Where a file path is specified, the file's parent directory must exist. Please consult the manual for further guidance.
";
Assert.AreEqual(expected, errorOutput, "Correct message written");
_terminator.Verify(x => x.Terminate(ApplicationTerminator.ExpectedErrorExitCode),
Times.Once(),
"Application should be terminated after writing message");
}
private FileSystemInfo GetOutputPath(CommandLineOptions options)
{
FileSystemInfo output;
if(String.IsNullOrEmpty(options.OutputPath))
{
output = null;
}
else
{
var absolutePath = MakeAbsolutePath(options.OutputPath);
if(Directory.Exists(absolutePath))
{
output = new DirectoryInfo(absolutePath);
}
else
{
FileInfo file;
try
{
file = new FileInfo(absolutePath);
}
catch(Exception ex)
{
throw new InvalidOutputPathException(ExceptionMessages.InvalidOutputFile, ex);
}
if(file.Directory.Exists)
{
output = file;
}
else
{
throw new InvalidOutputPathException(ExceptionMessages.InvalidOutputFile);
}
}
}
return output;
}
public void GetOptions_returns_expected_source_annotation_value(bool value)
{
// Arrange
var input = new CommandLineOptions() {
EnableSourceAnnotation = value
};
// Act
var result = _sut.GetOptions(input);
// Assert
Assert.AreEqual(value, result.AddSourceFileAnnotation);
}
