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