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);
}
