private void ExecuteProgram(Options argsResult)
        {
            _wordDictionaryService.Initialise(argsResult);

            var result = _wordladderSolver.SolveLadder(argsResult.StartWord,
                                                       argsResult.EndWord,
                                                       _wordDictionaryService.GetWordDictionary(),
                                                       _wordDictionaryService.GetPreprocessedWordsDictionary());

            WriteResultToTxtFile(result, argsResult.WordLadderResultFilePath);
        }
        public void GetPreprocessedWordsDictionary_ReturnsDictionaryOfStringAndCollectionOfStrings()
        {
            // Arrange
            _fileWrapper.FileExists(Arg.Any <string>());

            var sb = new StringBuilder();

            sb.AppendLine("A");
            sb.AppendLine("B");
            sb.AppendLine("C");
            var wordDictionaryFile = Encoding.UTF8.GetBytes(sb.ToString());
            var fakeMemoryStream   = new MemoryStream(wordDictionaryFile);

            StreamReader stream = null;

            _fileWrapper.StreamReader(Arg.Any <string>())
            .Returns(stream = new WordDictionaryStreamReader(fakeMemoryStream));

            _dictionaryPreprocessService
            .When(service => service.CreatePreprocessedDictionaries(Arg.Is(
                                                                        new DictionaryPreprocessServiceParams("A",
                                                                                                              new Dictionary <string, bool>(),
                                                                                                              new Dictionary <string, ICollection <string> >()))))
            .Do(d => d.ArgAt <DictionaryPreprocessServiceParams>(0).ListOfPreprocessedWords
                .Add("*", new List <string>()
            {
                "A", "B", "C"
            }));

            // Act
            var result = _sut.GetPreprocessedWordsDictionary();

            // Assert
            result.Keys.Should().ContainItemsAssignableTo <string>();

            result.Values.Should().ContainItemsAssignableTo <IEnumerable <string> >();

            stream.Dispose();
        }
        public void Execute_ValidatesInput_InitialisesDictionarires_SolvesWordLadder_WritesAnswerFile_OpensAnswerFile()
        {
            var exceptionCaught = false;

            var startWord = "sure";
            var endWord   = "HIRE";
            var wordDictionaryFilePath   = ".\\words.txt";
            var wordLadderResultFilePath = "answers.txt";
            var args = new Options(startWord, endWord, wordDictionaryFilePath, wordLadderResultFilePath);

            IDictionary <string, bool> dictionary = new Dictionary <string, bool>()
            {
                { "SAME", false },
                { "TIME", false },
                { "TAME", false },
                { "SOME", false },
                { "MUST", false },
                { "HIRE", false },
                { "SIRE", false },
                { "SITE", false }
            };
            IDictionary <string, ICollection <string> > preProcessedDictionary =
                new Dictionary <string, ICollection <string> >()
            {
                { "*AME", new[] { "SAME", "TAME" } },
                { "S*ME", new[] { "SAME", "SOME" } },
                { "SA*E", new[] { "SAME" } },
                { "SAM*", new[] { "SAME" } },
                { "T*ME", new[] { "TAME", "TIME" } },
                { "TA*E", new[] { "TAME" } },
                { "TAM*", new[] { "TAME" } },
                { "TI*E", new[] { "TAME" } },
                { "TIM*", new[] { "TIME" } },
                { "*OME", new[] { "SOME" } },
                { "SO*E", new[] { "SOME" } },
                { "SOM*", new[] { "SOME" } },
                { "*IRE", new[] { "SIRE", "HIRE" } },
                { "S*RE", new[] { "SIRE" } },
                { "SI*E", new[] { "SIRE", "SITE" } },
                { "SIR*", new[] { "SIRE" } },
                { "*ITE", new[] { "SITE" } },
                { "S*TE", new[] { "SITE" } },
                { "SIT*", new[] { "SITE" } }
            };
            var wordLadderSolved = new List <string>()
            {
                "SURE", "SIRE", "HIRE"
            };

            _inputValidator.Validate(Arg.Is <Options>(args), Arg.Invoke(args));
            _wordDictionaryService.Initialise(Arg.Is <Options>(args));
            _wordDictionaryService.GetWordDictionary().Returns(dictionary);
            _wordDictionaryService.GetPreprocessedWordsDictionary().Returns(preProcessedDictionary);
            _wordLadderSolver.SolveLadder(Arg.Is(startWord), Arg.Is(endWord), Arg.Is(dictionary),
                                          Arg.Is(preProcessedDictionary))
            .Returns(wordLadderSolved);

            // ACT
            _sut.Execute(args, s => { exceptionCaught = true; });

            // ASSERT
            Assert.False(exceptionCaught);
            _inputValidator.Received(1).Validate(Arg.Is <Options>(args), Arg.Invoke(args));

            _wordDictionaryService.Received(1).Initialise(Arg.Is <Options>(args));

            _wordLadderSolver.Received(1).SolveLadder(Arg.Is(startWord),
                                                      Arg.Is(endWord),
                                                      Arg.Is(dictionary),
                                                      Arg.Is(preProcessedDictionary));

            _openFileHelper.Received(1).OpenFile(Arg.Is <string>(a => a.Contains(wordLadderResultFilePath)));

            _fileWrapper.Received(1).Write(Arg.Any <IList <string> >(), Arg.Is(wordLadderResultFilePath));
        }