public void WordLadderProcessor_Finds_Word_Sequence_When_Exists() { //Arrange var mockIlloger = new Mock <ILogger <IWordLadderProcessor> >(); var mockOptions = new Mock <IOptions <WordLadderOptions> >(); var mockRepository = new Mock <IWordListRepository>(); var _path = Path.GetFullPath("./Data/words-english.txt"); var _dict = File.ReadAllLines(_path).Where(e => e.Length == 4).Select(e => e).ToList(); mockRepository.Setup(e => e.GetFiltered(It.IsAny <Func <string, bool> >())).Returns(_dict); WordLadderOptions wOp = new WordLadderOptions() { TypeOfSearch = JobPayloadCommand.SearchType.BREATH_FIRST, ResultsDefaultPath = _path }; mockOptions.Setup(e => e.Value).Returns(wOp); JobPayloadCommand payload = new JobPayloadCommand() { StartWord = "bard", EndWord = "chaw", TypeOfSearch = JobPayloadCommand.SearchType.BREATH_FIRST }; WordLadderProcessor _result = new WordLadderProcessor(mockIlloger.Object, mockRepository.Object, mockOptions.Object); ////Act var _processResult = _result.ProcessAsync(payload).Result; //Assert Assert.Equal(24, _processResult.Result.Count); }
public void Call_PublishMessageToAll_Call_publish_In_All_Publishers() { //Arrange var mockIlloger = new Mock <ILogger <IPublisherHub> >(); var mockpublisher1 = new Mock <IPublisher>(); var mockpublisher2 = new Mock <IPublisher>(); var mockpublisher3 = new Mock <IPublisher>(); var publisherList = new List <IPublisher>() { mockpublisher1.Object, mockpublisher2.Object, mockpublisher3.Object }; var repo = new PublisherHub(mockIlloger.Object, publisherList); //Act var msg = "Test Message"; JobPayloadCommand job = new JobPayloadCommand(); repo.PublishMessageToAll(msg, job); //Assert mockpublisher1.Verify(p => p.Publish(msg, job), Times.Once()); mockpublisher2.Verify(p => p.Publish(msg, job), Times.Once()); mockpublisher3.Verify(p => p.Publish(msg, job), Times.Once()); }
public void PublishMessageToAll(string message, JobPayloadCommand payload) { foreach (var publisher in _publishers) { publisher.Publish(message, payload); } }
public void Can_write_To_File_with_Path_from_Configuration() { //Arrange var mockIlloger = new Mock <ILogger <IPublisher> >(); var mockOptions = new Mock <IOptions <WordLadderOptions> >(); var _newFilePath = Path.Combine("./Data", Guid.NewGuid() + ".txt"); var _path = Path.GetFullPath(_newFilePath); WordLadderOptions wOp = new WordLadderOptions() { TypeOfSearch = JobPayloadCommand.SearchType.BREATH_FIRST, ResultsDefaultPath = _path }; mockOptions.Setup(e => e.Value).Returns(wOp); var _publisher = new FileSystemTextPublisher(mockIlloger.Object, mockOptions.Object); JobPayloadCommand payload = new JobPayloadCommand(); //Act _publisher.Publish("This is a test", payload); //Assert var _exist = File.Exists(_path); File.Delete(_path); Assert.True(_exist); }
public void Can_write_To_txt_file_from_string() { //Arrange var mockIlloger = new Mock <ILogger <IPublisher> >(); var mockOptions = new Mock <IOptions <WordLadderOptions> >(); var _newFilePath = Path.Combine("./Data", Guid.NewGuid() + ".txt"); var _path = Path.GetFullPath(_newFilePath); WordLadderOptions wOp = new WordLadderOptions() { TypeOfSearch = JobPayloadCommand.SearchType.BREATH_FIRST, ResultsDefaultPath = _path }; mockOptions.Setup(e => e.Value).Returns(wOp); var _publisher = new FileSystemTextPublisher(mockIlloger.Object, mockOptions.Object); JobPayloadCommand payload = new JobPayloadCommand(); //Act var _txt = "This is a test."; _publisher.Publish(_txt, payload); //Assert var fromFile = File.ReadAllText(_path); File.Delete(_path); Assert.Equal(fromFile, _txt); }
private void SetInitialResult(JobPayloadCommand payload) { _processingResult = new ProcessingResult(); _processingResult.Payload = payload; _processingResult.Start = DateTimeOffset.UtcNow; _processingResult.WasSuccefull = false; _processingResult.ResultMessage = "Unable to find a path bettween the start and end word"; }
public Task <ProcessingResult> ProcessAsync(JobPayloadCommand payload) { var _startWord = payload.StartWord; var _wordSize = _startWord.Length; SetInitialResult(payload); List <string> resultList = new List <string>() { _startWord }; _workingMatchList.Clear(); _workingWordList = _repository.GetFiltered((_word) => _word.Length == _wordSize); _workingWordList.Remove(_startWord); var _task = Task.Factory.StartNew(() => { bool keepProcessing = true; ResultEval cycleResult; MatchResult mResult = new MatchResult(_startWord, null); MatchResult pointer = null; cycleResult = MatchingCycleSearchable(_wordSize, mResult.SourceWord, mResult, payload); pointer = mResult; int counter = 0; keepProcessing = cycleResult == ResultEval.Continue; while (keepProcessing) { // foreach (var mr in pointer.MatchesList) { cycleResult = MatchingCycleSearchable(_wordSize, mr.SourceWord, mr, payload); keepProcessing = cycleResult == ResultEval.Continue; if (!keepProcessing) { break; } } pointer = payload.TypeOfSearch == JobPayloadCommand.SearchType.BREATH_FIRST ? NextNodeBreadFirst(pointer) : NextNodeDeepFirst(pointer); keepProcessing &= pointer != null; counter++; } // }); _task.Wait(); PrepareResult(payload); return(Task.FromResult(_processingResult)); }
private void PrepareResult(JobPayloadCommand payload) { if (_processingResult.Result.Count > 0) { _processingResult.WasSuccefull = true; _processingResult.ResultMessage = "Found a sequence between the start and end words."; } if (_processingResult.End == null) { _processingResult.End = DateTimeOffset.UtcNow; } }
private ResultEval IsFinal(List <string> resultsList, string endWord, JobPayloadCommand payload) { ResultEval resultEval = ResultEval.Continue; if (resultsList.Contains(endWord)) { resultEval = ResultEval.IsFinalOK; } return(resultEval); }
public void Publish(string message, JobPayloadCommand payload) { try { var filePath = ResolveFilePath(payload); SaveFile(filePath, message); } catch (Exception e) { _logger.LogError("Error writing result {0}:{1}", e.Message, e.StackTrace); } }
public static JobPayloadCommand LoadJob(string[] _args, JobPayloadCommand.SearchType searchType) { JobPayloadCommand j = new JobPayloadCommand(); if (_args != null && _args.Length > 0) { var dict = keyValuePairs(_args); j.StartWord = dict[_s]; j.EndWord = dict[_f]; j.SourceFilePath = dict[_d]; j.ResultPublicationPath = dict[_o]; j.TypeOfSearch = searchType; } return(j); }
//public List<string> Process(List<string> wordList, JobPayload payload) //{ // var _startWord = payload.StartWord; // List<string> resultList = new List<string>() { _startWord }; // var _wordSize = _startWord.Length; // _workingWordList = wordList.Where(e => e.Length == _wordSize).Select(e => e).ToList(); // _workingWordList.Remove(_startWord); // List<string> _currentMatches = new List<string>() { _startWord }; // List<string> _nextMatches = new List<string>(); // bool keepProcessing = true; // while (keepProcessing) // { // foreach (var s in _currentMatches) // { // keepProcessing &= !MatchingCycle(_wordSize, s, _nextMatches, payload); // _nextMatches = RemoveDuplicates(_nextMatches); // } // _currentMatches = RemoveDuplicates(_nextMatches); // } // return resultList; //} public List <string> ProcessTwo(List <string> wordList, JobPayloadCommand payload) { var _startWord = payload.StartWord; var _wordSize = _startWord.Length; List <string> resultList = new List <string>() { _startWord }; _workingMatchList = new List <string>(); _workingWordList = wordList.Where(e => e.Length == _wordSize).Select(e => e).ToList(); _workingWordList.Remove(_startWord); bool keepProcessing = true; MatchResult mResult = new MatchResult(_startWord, null); MatchResult pointer = null; keepProcessing &= !MatchingCycleSearchable(_wordSize, mResult.SourceWord, mResult, payload); pointer = mResult; int counter = 0; while (keepProcessing) { Console.WriteLine($"Nível: {counter}"); foreach (var mr in pointer.MatchesList) { keepProcessing &= !MatchingCycleSearchable(_wordSize, mr.SourceWord, mr, payload); // _nextMatches = RemoveDuplicates(_nextMatches); //PrintNode(mr); if (!keepProcessing) { break; } } //_currentMatches = RemoveDuplicates(_nextMatches); pointer = NextNodeBreadFirst(pointer); keepProcessing &= pointer != null; counter++; } return(resultList); }
public void Can_write_To_txt_file_from_ProcessingResult() { //Arrange var mockIlloger = new Mock <ILogger <IPublisher> >(); var mockOptions = new Mock <IOptions <WordLadderOptions> >(); var _newFilePath = Path.Combine("./Data", Guid.NewGuid() + ".txt"); var _path = Path.GetFullPath(_newFilePath); WordLadderOptions wOp = new WordLadderOptions() { TypeOfSearch = JobPayloadCommand.SearchType.BREATH_FIRST, ResultsDefaultPath = _path }; mockOptions.Setup(e => e.Value).Returns(wOp); var _publisher = new FileSystemTextPublisher(mockIlloger.Object, mockOptions.Object); JobPayloadCommand payload = new JobPayloadCommand(); ProcessingResult _result = new ProcessingResult(); _result.Payload = payload; _result.WasSuccefull = true; _result.Result.Add("Test"); _result.Result.Add("Pest"); _result.Result.Add("Post"); //Act _publisher.Publish(_result); //Assert var fromFile = File.ReadAllLines(_path); File.Delete(_path); Assert.Equal("Post", fromFile[fromFile.Length - 1]); Assert.Equal("Pest", fromFile[fromFile.Length - 2]); Assert.Equal("Test", fromFile[fromFile.Length - 3]); }
public void Publish(string message, JobPayloadCommand payload) { Console.WriteLine(payload.Print()); Console.WriteLine(message); }
private string ResolveFilePath(JobPayloadCommand payload) { return(string.IsNullOrEmpty(payload.ResultPublicationPath) ? wordLadderOptions.ResultsDefaultPath : payload.ResultPublicationPath); }
private string ResolveFilePath(JobPayloadCommand payload) { var _path = string.IsNullOrEmpty(payload.ResultPublicationPath) ? wordLadderOptions.ResultsDefaultPath : payload.ResultPublicationPath; return(_path.Replace(".txt", ".csv")); }
//private bool MatchingCycle(int _wordSize, string _startWord, List<string> _matchedList, JobPayload payload) //{ // var mutations = GenerateMutations(_wordSize, _startWord); // var regexSet = GenerateRegex(_wordSize, mutations); // _matchedList.AddRange(GenerateMatchesForBreathFirst(regexSet)); // return IsFinal(_matchedList, payload.EndWord); //} private bool MatchingCycleSearchable(int _wordSize, string _startWord, MatchResult mResult, JobPayloadCommand payload) { var mutations = GenerateMutations(_wordSize, _startWord); var regexSet = GenerateRegex(_wordSize, mutations); GenerateMatchesForDeepFirst(regexSet, mResult); var isfinal = IsFinal(mResult.MatchesList.Select(e => e.SourceWord).ToList(), payload.EndWord); if (isfinal) { File.WriteAllText(payload.ResultPublicationPath, PrintPath(mResult, payload.EndWord)); //PrintPath(mResult); } return(isfinal); }
private ResultEval MatchingCycleSearchable(int _wordSize, string _startWord, MatchResult mResult, JobPayloadCommand payload) { var mutations = GenerateMutations(_wordSize, _startWord); var regexSet = GenerateRegex(_wordSize, mutations); GenerateMatches(regexSet, mResult); var isfinal = IsFinal(mResult.MatchesList.Select(e => e.SourceWord).ToList(), payload.EndWord, payload); if (isfinal == ResultEval.IsFinalNotOK || isfinal == ResultEval.IsFinalOK) { _processingResult.Result.AddRange(GetTreeLine(mResult, payload.EndWord)); if (isfinal == ResultEval.IsFinalOK) { _processingResult.End = DateTimeOffset.UtcNow; _processingResult.WasSuccefull = true; } } return(isfinal); }