class Program

{
static void Main(string[] args)
{
var factory = new Factory();
var workflow = factory.NewWorkflowManager();
workflow.Run(args);
}
}
public class WorkFlowManager
{
private readonly IParser<IArgumentsValues> _commandLineParser;
private readonly IFileSystem _fileSystem;
private readonly IConsoleService _consoleService;
public WorkFlowManager(IFactory factory)
{
_commandLineParser = factory.CommandLineParser;
_fileSystem = factory.FileSystem;
_consoleService = factory.ConsoleService;
}
public void Run(string[] args)
{
_commandLineParser.ReadArgs(args);
if (_commandLineParser.UsageShouldBeDisplayed)
{
ShowHelp(_commandLineParser.Usage);
return;
}
Run(_commandLineParser.Parse());
}
private void Run(IArgumentsValues arguments)
{
var inputRunner = new InputFactory(arguments.InputFile)
.WithFileSystem(_fileSystem)
.WithConsoleService(_consoleService);
var inputContent = inputRunner.InputReader().Read();
var dictionaryRunner = new InputFactory(arguments.DictionaryFile)
.WithFileSystem(_fileSystem)
.WithConsoleService(_consoleService);
var dicitonaryInput = dictionaryRunner.InputReader().Read();
//var processor = new Processor(inputContent, dicitonaryInput);
//var result = processor.Process();
//Display(result);
}
private static void ShowHelp(string usage)
{
Console.Write(usage);
}
}

[TestFixture]

public class WorkFlowManagerTest

{
private Mock<IParser<IArgumentsValues>> _parser;
private Mock<IFactory> _factory;
private WorkFlowManager _workFlowManager;
private Mock<FileSystemMock> _fileSystem;
private Mock<IConsoleService> _consoleService;
[SetUp]
public void SetUp()
{
_fileSystem = FileSystemMock.New();
_consoleService = new Mock<IConsoleService>();
_factory = new Mock<IFactory>();
_factory.SetupGet(x => x.FileSystem).Returns(_fileSystem.Object);
_factory.SetupGet(x => x.ConsoleService).Returns(_consoleService.Obj
ect);
var arguments = Mock.Of<IArgumentsValues>();
_parser = new Mock<IParser<IArgumentsValues>>();
_parser.Setup(x => x.Parse()).Returns(arguments);
_parser.Setup(x => x.Usage).Returns("Special usage");
_factory.Setup(x => x.CommandLineParser)
.Returns(_parser.Object);
_workFlowManager = new WorkFlowManager(_factory.Object);
}
[Test]
public void PassesTheArgumentsToTheParser()
{
var args = new[] { "-I", "-O" };
WhenRan(args);
_parser.Verify(x => x.ReadArgs(args), "Parser.ReadArgs");
}
[Test]
public void ShowsHelpWithNoArgs()
{
WithAShowHelpCommandLine();
WhenRan();
_parser.Verify(x => x.Usage, "Help displayed");
}
[Test]
public void DoesNotShowTheHelpWithValidArguments()
{
WhenRan();
_parser.Verify(x=>x.Usage, Times.Never(), "Help displayed");
}
[Test]
public void ParserParsesTheArguments()
{
var args = new[] { "-I", "-O" };
WhenRan(args);
_parser.Verify(x => x.ReadArgs(args), "Parser.ReadArgs");
_parser.Verify(x => x.Parse(), "Parser.Parse");
}
private void WithAShowHelpCommandLine()
{
_parser.SetupGet(x => x.UsageShouldBeDisplayed).Returns(true);

}
private void WhenRan(params string[] args)
{
_workFlowManager.Run(args);
}
}