private List <Search> GetSearchWinners(ContainerSearch containerSearch)
{
if (containerSearch == null || containerSearch.termDictionary.Count == 0)
{
throw new ArgumentException("Invalid arguments", nameof(containerSearch));
}
var termsDictionary = containerSearch.termDictionary;
// set the first dictionary element as a temporary search winners
List <Search> searchWinners = SetFirstElemAsWinner(termsDictionary);
// searchWinners is updated while iterating through the dictionary elements
for (int i = 1; i < termsDictionary.Count; i++)
{
string keyTerm = termsDictionary.ElementAt(i).Key;
List <Search> searchEngineList = termsDictionary.ElementAt(i).Value;
for (int j = 0; j < searchEngineList.Count; j++)
{
long searchMaxResult = searchWinners.ElementAt(j).TotalQueryResults;
long totalResults = searchEngineList.ElementAt(j).TotalQueryResults;
if (totalResults > searchMaxResult)
{
searchWinners.ElementAt(j).TotalQueryResults = totalResults;
searchWinners.ElementAt(j).Term = keyTerm;
}
}
}
// return the search winners list
return(searchWinners);
}
public IList <string> PrintSearchResults(ContainerSearch containerSearch)
{
if (containerSearch == null || containerSearch.termDictionary.Count == 0)
{
throw new ArgumentException("The parameter is invalid", nameof(containerSearch));
}
var termsDictionary = containerSearch.termDictionary;
List <string> searchResults = new List <string>();
StringBuilder resultBuilder = new StringBuilder();
foreach (var termDict in termsDictionary)
{
resultBuilder.Append(termDict.Key);
resultBuilder.Append(": ");
foreach (var search in termDict.Value)
{
resultBuilder.Append(search.EngineName);
resultBuilder.Append(": ");
resultBuilder.Append(search.TotalQueryResults);
resultBuilder.Append(" ");
}
searchResults.Add(resultBuilder.ToString());
resultBuilder.Clear();
}
return(searchResults);
}
public async Task <ContainerSearch> GetSearchEngineResults(IList <string> terms)
{
if (terms == null || terms.Count().Equals(0))
{
throw new ArgumentException("The input arguments are invalid", nameof(terms));
}
ContainerSearch containerSearch = new ContainerSearch();
foreach (string term in terms)
{
List <Search> searchResutls = new List <Search>();
foreach (ISearchEngine engine in _searchEngines)
{
Search search = new Search
{
Term = term,
EngineName = engine.Name,
TotalQueryResults = await engine.GetTotalResultsAsync(term)
};
searchResutls.Add(search);
}
containerSearch.termDictionary.Add(term, searchResutls);
}
return(containerSearch);
}
public void PrintSearchResults_Success()
{
ContainerSearch containerSearch = GetContainerSearchMockData();
IList <string> searchResultReport = _reportManager.PrintSearchResults(containerSearch);
Assert.NotNull(searchResultReport);
Assert.AreNotEqual(0, searchResultReport.Count);
}
public List <EngineTermWinner> GetEngineWinners(ContainerSearch containerSearch)
{
if (containerSearch == null || containerSearch.termDictionary.Count == 0)
{
throw new ArgumentException("Invalid arguments", nameof(containerSearch));
}
List <Search> searchWinners = GetSearchWinners(containerSearch);
return(ParseToEngineWinners(searchWinners));
}
public async Task GetSearchEngineResults_Success()
{
List <string> terms = new List <string>
{
".net", "java", "net", ",java"
};
ContainerSearch containerSearch = await _searchManager.GetSearchEngineResults(terms);
Assert.IsNotNull(containerSearch);
Assert.IsNotEmpty(containerSearch.termDictionary);
}
public static async Task StartAsync(IList <string> terms)
{
ContainerSearch searchDataContainer = await SearchManager.GetSearchEngineResults(terms);
Reports.AddRange(ReportManager.PrintSearchResults(searchDataContainer));
List <EngineTermWinner> SearchEngineWinners = WinnerManager.GetEngineWinners(searchDataContainer);
Reports.AddRange(ReportManager.PrintWinners(SearchEngineWinners));
EngineTermWinner totalwinner = WinnerManager.GetTotalWinner(searchDataContainer);
Reports.Add(ReportManager.PrintTotalWinner(totalwinner));
}
private ContainerSearch GetContainerSearchMockData()
{
ContainerSearch containerSearch = new ContainerSearch
{
termDictionary = new Dictionary <string, List <Search> >
{
{ ".net", new List <Search>
{
new Search {
EngineName = "Google", Term = ".net", TotalQueryResults = 99987543876L
},
new Search {
EngineName = "Bing", Term = ".net", TotalQueryResults = 865464876L
},
new Search {
EngineName = "Aol", Term = ".net", TotalQueryResults = 176587748L
}
} },
{ "java", new List <Search>
{
new Search {
EngineName = "Google", Term = "java", TotalQueryResults = 87543876L
},
new Search {
EngineName = "Bing", Term = "java", TotalQueryResults = 99965464876L
},
new Search {
EngineName = "Aol", Term = "java", TotalQueryResults = 76587748L
}
} },
{ "java script", new List <Search>
{
new Search {
EngineName = "Google", Term = "java script", TotalQueryResults = 7543876L
},
new Search {
EngineName = "Bing", Term = "java script", TotalQueryResults = 5464876L
},
new Search {
EngineName = "Aol", Term = "java script", TotalQueryResults = 99996587748L
}
} }
}
};
return(containerSearch);
}
public EngineTermWinner GetTotalWinner(ContainerSearch containerSearch)
{
if (containerSearch == null || containerSearch.termDictionary.Count == 0)
{
throw new ArgumentException("Invalid arguments", nameof(containerSearch));
}
// get the winner list
List <Search> winners = GetSearchWinners(containerSearch);
// set the first winner as a Total Winner
Search tempTotalWinner = winners.First();
// start iterating at position 1, for position 0 is the
// tempTotalWinner
for (int i = 1; i < winners.Count; i++)
{
long winnerTotalResults = winners.ElementAt(i).TotalQueryResults;
long tempWinnerTotalResults = tempTotalWinner.TotalQueryResults;
// update total winner
if (winnerTotalResults > tempWinnerTotalResults)
{
tempTotalWinner = winners.ElementAt(i);
}
}
// set the engine term winner with the data of the total Winner
EngineTermWinner engineTermWinner = new EngineTermWinner
{
EngineName = tempTotalWinner.EngineName,
Term = tempTotalWinner.Term
};
return(engineTermWinner);
}
public void GetTotalWinner_Empty_ArgumentException()
{
ContainerSearch containerSearch = new ContainerSearch();
Assert.Throws <ArgumentException>(() => _winnerManager.GetTotalWinner(containerSearch));
}
public void GetEngineWinners_Null_ArgumentException()
{
ContainerSearch containerSearch = null;
Assert.Throws <ArgumentException>(() => _winnerManager.GetEngineWinners(containerSearch));
}
public void PrintSearchResults_Empty_ArgumentException()
{
ContainerSearch containerSearch = new ContainerSearch();
Assert.Throws <ArgumentException>(() => _reportManager.PrintSearchResults(containerSearch));
}
