static void ParseDirectoryWithParser(string directory, RepositoryParser repositoryParser, bool printConverted)
{
var dirInfo = new DirectoryInfo(directory);
FileInfo[] files = dirInfo.GetFiles("*.txt");
Console.WriteLine("Parsing {0} files.", files.Length);
int fileCounter = 0;
foreach (FileInfo file in files)
{
try
{
string handHistories = new StreamReader(file.OpenRead()).ReadToEnd();
IEnumerable <IConvertedPokerHand> convertedPokerHands =
repositoryParser.RetrieveAndConvert(handHistories, file.FullName);
if (printConverted)
{
PrintToConsole(convertedPokerHands);
}
fileCounter++;
}
catch (Exception excep)
{
Console.WriteLine("File #{0} name is {1}", fileCounter, file.Name);
Console.WriteLine(excep);
}
}
Console.WriteLine("Finished Files #{0}", fileCounter);
}
public async Task <List <Transformation> > GetTransformations(TransformationQuery query)
{
var content = await RepositoryParser.ParseRepository <List <Transformation> >(filePaths.Transformations);
var queryedItems = FilterTransformations(content, query);
return(queryedItems);
}
public async Task <List <Ability> > GetAbilities(AbilityQuery query)
{
var content = await RepositoryParser.ParseRepository <List <Ability> >(filePaths.Abilities);
var queryedItems = FilterAbilites(content, query);
return(queryedItems);
}
public async Task <List <Level> > GetLevels(LevelQuery query)
{
var content = await RepositoryParser.ParseRepository <List <Level> >(filePaths.Levels);
var queryedItems = FilterLevels(content, query);
return(queryedItems);
}
public async Task <List <Game> > GetGames(GameQuery query)
{
var content = await RepositoryParser.ParseRepository <List <Game> >(filePaths.Games);
var queryedItems = FilterGames(content, query);
return(queryedItems);
}
public async Task <List <Area> > GetAreas(AreaQuery query)
{
var content = await RepositoryParser.ParseRepository <List <Area> >(filePaths.Areas);
var queryedItems = FilterAreas(content, query);
return(queryedItems);
}
public async Task <List <Collectable> > GetCollectables(CollectableQuery query)
{
var content = await RepositoryParser.ParseRepository <List <Collectable> >(filePaths.Collectables);
var queryedItems = FilterCollectables(content, query);
return(content);
}
public async Task<List<Enemy>> GetEnemies(EnemyQuery query)
{
var content = await RepositoryParser.ParseRepository<List<Enemy>>(filePaths.Enemies);
var queryedItems = FilterEnemies(content, query);
return queryedItems;
}
public async Task <List <Character> > GetCharacters(CharacterQuery query)
{
var contents = await RepositoryParser.ParseRepository <List <Character> >(filePaths.Characters);
var queryedItems = FilterCharacters(contents, query);
return(queryedItems);
}
public void RetrieveAndConvert_EmptyString_ThrowsUnrecognizedHandHistoryFormatException()
{
_parsers.Add(_mockParser.Object);
var repositoryParser = new RepositoryParser(_parsers, _stub.Out <IConstructor <IPokerHandConverter> >());
Assert.Throws <UnrecognizedHandHistoryFormatException>(
() => repositoryParser.RetrieveAndConvert(string.Empty, FileName));
}
public void RetrieveAndConvert_ParserSeparateHandHistoriesReturnsEmpty_DoesNotCallParseOnParser()
{
Mock <IPokerHandParser> mockParser =
ParserThatRecognizesHandsButReturnsEmptyWhenExtractingHands(SomeHandHistoriesString);
_parsers.Add(mockParser.Object);
var repositoryParser = new RepositoryParser(_parsers, _stub.Out <IConstructor <IPokerHandConverter> >());
repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName);
mockParser.Verify(parser => parser.ParseHand(It.IsAny <string>()), Times.Never());
}
public void RetrieveAndConvert_ParserRecognizesHandHistory_SeparatesHandHistories()
{
Mock <IPokerHandParser> mockParser =
ParserThatRecognizesHandsButReturnsEmptyWhenExtractingHands(SomeHandHistoriesString);
_parsers.Add(mockParser.Object);
var repositoryParser = new RepositoryParser(_parsers, _stub.Out <IConstructor <IPokerHandConverter> >());
repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName);
mockParser.Verify(parser => parser.ExtractSeparateHandHistories(SomeHandHistoriesString));
}
public void RetrieveAndConvert_NoParserRecognizesHandHistory_ThrowsUnrecognizedHandHistoryFormatException()
{
const bool recognizeHandHistories = false;
_mockParser
.Setup(parser => parser.RecognizesHandHistoriesIn(SomeHandHistoriesString))
.Returns(recognizeHandHistories);
_parsers.Add(_mockParser.Object);
var repositoryParser = new RepositoryParser(_parsers, _stub.Out <IConstructor <IPokerHandConverter> >());
Assert.Throws <UnrecognizedHandHistoryFormatException>(
() => repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName));
}
public void RetrieveAndConvert_ParserSeparateHandHistoriesReturnsEmpty_DoesNotCallConvertOnHandConverter()
{
Mock <IPokerHandParser> stubParser =
ParserThatRecognizesHandsButReturnsEmptyWhenExtractingHands(SomeHandHistoriesString);
_parsers.Add(stubParser.Object);
var mockHandConverter = new Mock <IPokerHandConverter>();
var repositoryParser = new RepositoryParser(_parsers, new Constructor <IPokerHandConverter>(() => mockHandConverter.Object));
repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName);
mockHandConverter.Verify(
converter => converter.ConvertAquiredHand(It.IsAny <IAquiredPokerHand>()), Times.Never());
}
public void RetrieveAndConvert_ParserCanParseIt_ReturnsConvertedPokerHands()
{
const int extractedGameId = 1;
Mock <IPokerHandParser> stubParser =
ParserThatRecognizesAndSeparatesHandsAndParseSetsAquiredHandTo(extractedGameId);
_parsers.Add(stubParser.Object);
Mock <IPokerHandConverter> mockConverter = ConverterThatReturnsConvertedHandWith(extractedGameId);
var repositoryParser = new RepositoryParser(_parsers, new Constructor <IPokerHandConverter>(() => mockConverter.Object));
IEnumerable <IConvertedPokerHand> convertedHands =
repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName);
Assert.That(convertedHands.First().GameId, Is.EqualTo(extractedGameId));
}
RetrieveAndConvert_ParserSeparateHandHistoriesReturnsNonEmpty_CallsConvertOnConverterOnceWithThatHistory()
{
const int extractedGameId = 1;
Expression <Func <IAquiredPokerHand, bool> > handToBeConverted = h => h.GameId == extractedGameId;
Mock <IPokerHandParser> stubParser =
ParserThatRecognizesAndSeparatesHandsAndParseSetsAquiredHandTo(extractedGameId);
_parsers.Add(stubParser.Object);
Mock <IPokerHandConverter> mockConverter = ConverterThatReturnsConvertedHandWith(extractedGameId);
var repositoryParser = new RepositoryParser(_parsers, new Constructor <IPokerHandConverter>(() => mockConverter.Object));
repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName);
mockConverter.Verify(
c => c.ConvertAquiredHand(It.Is(handToBeConverted)), Times.Once());
}
public void RetrieveAndConvert_SameHandTwice_CallsParseOnParserOnlyOnce()
{
const string extractedHistory = "someHistory";
const int extractedGameId = 1;
var extractedHistories = new Dictionary <ulong, string> {
{ extractedGameId, extractedHistory }
};
Mock <IPokerHandParser> mockParser =
ParserThatRecognizesHandsAndWhenExtractingHandsReturns(extractedHistories, SomeHandHistoriesString);
_parsers.Add(mockParser.Object);
Mock <IPokerHandConverter> stubConverter = ConverterThatReturnsConvertedHandWith(extractedGameId);
var repositoryParser = new RepositoryParser(_parsers, new Constructor <IPokerHandConverter>(() => stubConverter.Object));
repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName);
repositoryParser.RetrieveAndConvert(SomeHandHistoriesString, FileName);
mockParser.Verify(parser => parser.ParseHand(extractedHistory), Times.Once());
}
