public async Task NonPauseNodesShouldNotBeAtEndOfBalloonNode() { var parentContext = new FakeParentParsingContext(); var context = Helper.FakeParsingContext(); var reader = A.Dummy <XmlReader>(); A.CallTo(() => reader.ReadState).Returns(ReadState.Interactive); var dummyNode1 = A.Dummy <IPauseNode>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).AddNode(dummyNode1)); var dummyNode2 = A.Dummy <INode>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).AddNode(dummyNode2)); await sut.ParseAsync(reader, context, parentContext); parentContext.Nodes.Count.Should().Be(2); parentContext.Nodes[0].Should().BeOfType <BalloonNode>().Which.ShouldSatisfy(i => { i.BallonType.Should().Be(BalloonType.Speech); i.ChildBlock.ShouldContainOnly(dummyNode1); }); parentContext.Nodes[1].Should().BeSameAs(dummyNode2); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)).MustHaveHappenedOnceExactly(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)).MustHaveHappenedOnceExactly(); }
public async Task ParseAsyncShouldReturnProtagonistNode(string parsedValue, string protagonistName) { var reader = A.Dummy <XmlReader>(); var context = A.Dummy <IParsingContext>(); var parentContext = new FakeParentParsingContext(); var when = A.Dummy <ICondition>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => { var ctx = i.GetArgument <IParentParsingContext>(2); ctx.ParsedText = parsedValue; ctx.When = when; }); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldContainSingle <ProtagonistNode>(i => { i.ProtagonistName.Should().Be(protagonistName); i.When.Should().BeSameAs(when); }); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)).MustHaveHappenedOnceExactly(); }
public async Task ParseAsyncShouldReturnAPersonNode() { var reader = A.Dummy <XmlReader>(); var context = Helper.FakeParsingContext(); var parentContext = new FakeParentParsingContext(); var sceneContext = A.Dummy <IParsingSceneContext>(); A.CallTo(() => context.SceneContext).Returns(sceneContext); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = "lorenipsum"); var dummyNode = A.Dummy <INode>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).AddNode(dummyNode)); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldContainSingle <PersonNode>(i => { i.PersonName.Should().Be("lorenipsum"); i.ChildBlock.ShouldBeEquivalentTo(sut.InitializeMoodNode, dummyNode, sut.DismissMoodNode); } ); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .MustHaveHappenedOnceExactly(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .MustHaveHappenedOnceExactly(); }
public async Task ShouldLogErrorWhenHasMoodIsTrue() { var message = "Foi definido humor mas não foi definida uma fala ou pensamento correspondente."; var reader = A.Dummy <XmlReader>(); var parentContext = new FakeParentParsingContext(); var sceneContext = A.Fake <IParsingSceneContext>(i => i.Strict()); A.CallTo(() => sceneContext.HasMood).Returns(true); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.SceneContext).Returns(sceneContext); A.CallTo(() => context.LogError(reader, message)).DoesNothing(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = "lorenipsum"); var dummyNode = A.Dummy <INode>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).AddNode(dummyNode)); await sut.ParseAsync(reader, context, parentContext); A.CallTo(() => context.LogError(reader, message)).MustHaveHappenedOnceExactly(); }
public async Task ShouldLogTextSourceParsingError() { var errorMessage = "Erro proposital."; var reader = A.Dummy <XmlReader>(); var parentContext = new FakeParentParsingContext(); var parsingResult = A.Dummy <ITextSourceParserResult>(); A.CallTo(() => parsingResult.IsError).Returns(true); A.CallTo(() => parsingResult.ErrorMessage).Returns(errorMessage); A.CallTo(() => textSourceParser.Parse("abc")).Returns(parsingResult); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.LogError(reader, errorMessage)).DoesNothing(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = "abc"); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .DoesNothing(); await sut.ParseAsync(reader, context, parentContext); A.CallTo(() => context.LogError(reader, errorMessage)).MustHaveHappenedOnceExactly(); }
public async Task ParseAsyncShouldReturnMusicNode(string parsedValue, string musicName) { var reader = A.Dummy <XmlReader>(); var context = A.Dummy <IParsingContext>(); var parentContext = new FakeParentParsingContext(); var when = A.Dummy <ICondition>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => { var ctx = i.Arguments.Get <IParentParsingContext>(2); ctx.ParsedText = parsedValue; ctx.When = when; }); await sut.ParseAsync(reader, context, parentContext); var node = parentContext.Nodes.Should().ContainSingle() .Which.Should().BeOfType <MusicNode>() .Which.Should().BeEquivalentTo(new { MusicName = musicName, When = when }); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)).MustHaveHappenedOnceExactly(); }
public async Task ShouldLogErrorWhenHasMoodIsTrue() { var message = "Mais de uma definição de humor para a mesma cena."; var reader = A.Dummy <XmlReader>(); var parentContext = new FakeParentParsingContext(); var sceneContext = A.Fake <IParsingSceneContext>(i => i.Strict()); A.CallTo(() => sceneContext.HasMood).Returns(true); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.SceneContext).Returns(sceneContext); A.CallTo(() => context.LogError(reader, message)).DoesNothing(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.GetArgument <IParentParsingContext>(2).ParsedText = "Happy"); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldBeEmpty(); A.CallTo(() => context.LogError(reader, message)).MustHaveHappenedOnceExactly(); }
public async Task Aggregation() { var parentContext = new FakeParentParsingContext(); var context = Helper.FakeParsingContext(); var reader = A.Dummy <XmlReader>(); A.CallTo(() => reader.ReadState).Returns(ReadState.Interactive); var dummyNode1 = A.Dummy <IPauseNode>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).AddNode(dummyNode1)); var dummyNode2 = A.Dummy <IPauseNode>(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).AddNode(dummyNode2)); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldContainSingle <BalloonNode>(i => { i.BallonType.Should().Be(BalloonType.Speech); i.ChildBlock.ShouldBeEquivalentTo(dummyNode1, dummyNode2); }); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)).MustHaveHappenedOnceExactly(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)).MustHaveHappenedOnceExactly(); }
public UnsetNodeParserTests() { reader = A.Dummy <XmlReader>(); context = A.Fake <IParsingContext>(i => i.Strict()); parentContext = new(); elementParser = A.Fake <IElementParser>(i => i.Strict()); nameTextParser = A.Fake <INameTextParser>(i => i.Strict()); sut = new(elementParser, nameTextParser); }
public SetNodeParserTests() { reader = A.Dummy <XmlReader>(); context = A.Fake <IParsingContext>(i => i.Strict()); parentContext = new(); varSetParser = A.Fake <IVarSetParser>(i => i.Strict()); elementParser = A.Fake <IElementParser>(i => i.Strict()); varSetTextParser = A.Fake <IVarSetTextParser>(i => i.Strict()); sut = new(varSetParser, elementParser, varSetTextParser); }
public async Task ParseAsyncShouldReturnNullIfParsedTextIsNull() { var reader = A.Dummy <XmlReader>(); var context = A.Dummy <IParsingContext>(); var parentContext = new FakeParentParsingContext(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)).DoesNothing(); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldBeEmpty(); }
public async Task ParseAsyncShouldDelegateAllToElementParser() { var context = A.Fake <IParsingContext>(i => i.Strict()); var parentContext = new FakeParentParsingContext(); var reader = A.Dummy <XmlReader>(); A.CallTo(() => elementParser.ParseAsync(reader, context, parentContext, sut.Settings)).DoesNothing(); await sut.ParseAsync(reader, context, parentContext); A.CallTo(() => elementParser.ParseAsync(reader, context, parentContext, sut.Settings)).MustHaveHappenedOnceExactly(); }
public async Task ParseAsyncShouldReturnMoodNode() { var reader = A.Dummy <XmlReader>(); var context = A.Dummy <IParsingContext>(); var parentContext = new FakeParentParsingContext(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.GetArgument <IParentParsingContext>(2).ParsedText = "Happy"); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldContainSingle <MoodNode>(i => i.MoodType.Should().Be(MoodType.Happy)); }
public async Task AggregateNodeParser() { using var reader = Helper.CreateReader("<t><a /></t>"); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); var node = A.Dummy <INode>(); var nodeParser = new FakeNodeParser("a", node); var sut = new ElementParser(); var settings = FakeSettings(new FakeAggregatedNodeParser(sut, nodeParser)); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.ShouldContainSingle(node); }
public async Task ParseAsyncShouldLogErrorIfParsedTextIsEmpty() { var errorMessage = "Era esperado o nome do personagem."; var reader = A.Dummy <XmlReader>(); var context = A.Fake <IParsingContext>(i => i.Strict()); var parentContext = new FakeParentParsingContext(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = string.Empty); A.CallTo(() => context.LogError(reader, errorMessage)).DoesNothing(); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldBeEmpty(); A.CallTo(() => context.LogError(reader, errorMessage)).MustHaveHappenedOnceExactly(); }
public async Task Aggregated() { using var reader = Helper.CreateReader("<t><a /><b /></t>"); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); var node = A.Dummy <INode>(); var settings = FakeSettings(new FakeNodeParser("a", node)); A.CallTo(() => settings.NoRepeatNode).Returns(false); A.CallTo(() => settings.ExitOnUnknownNode).Returns(true); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); reader.LocalName.Should().Be("b"); }
public async Task InvalidContent(string xmlContent, string message) { using var reader = Helper.CreateReader(xmlContent); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.LogError(reader, message)).DoesNothing(); var textParser = A.Fake <ITextParser>(i => i.Strict()); var settings = FakeSettings(textParser); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.ShouldBeEmpty(); A.CallTo(() => context.LogError(reader, message)).MustHaveHappenedOnceExactly(); }
public async Task UnconfiguredText() { const string message = "Este elemento não permite texto."; using var reader = Helper.CreateReader("<t>Pindamonhangaba</t>"); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.LogError(reader, message)).DoesNothing(); var settings = FakeSettings(); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.ShouldBeEmpty(); A.CallTo(() => context.LogError(reader, message)).MustHaveHappenedOnceExactly(); }
public async Task ShouldReturnNodeWhenParsedTextIsNotNull() { var reader = A.Dummy <XmlReader>(); var context = A.Dummy <IParsingContext>(); var parentContext = new FakeParentParsingContext(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = "abc"); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .DoesNothing(); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldContainSingle <BalloonTextNode>(i => { i.TextSource.Should().BeSameAs(textSource); i.BalloonType.Should().Be(balloonType); }); }
public async Task AttributeParsing(string xml, bool hasWhen, bool hasWhile) { using var reader = Helper.CreateReader(xml); var context = A.Dummy <IParsingContext>(); var whenAttribute = A.Dummy <WhenAttribute>(); var whileAttribute = A.Dummy <WhileAttribute>(); var parentContext = new FakeParentParsingContext(); var whenParser = Helper.FakeParser <IAttributeParser>("when"); A.CallTo(() => whenParser.Parse(reader, context)).Returns(whenAttribute); var whileParser = Helper.FakeParser <IAttributeParser>("while"); A.CallTo(() => whileParser.Parse(reader, context)).Returns(whileAttribute); var settings = FakeSettings(whenParser, whileParser); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.ParsedText.Should().BeNull(); if (hasWhen) { parentContext.When.Should().BeSameAs(whenAttribute.Condition); } else { parentContext.When.Should().BeNull(); } if (hasWhile) { parentContext.While.Should().BeSameAs(whileAttribute.Condition); } else { parentContext.While.Should().BeNull(); } }
public async Task ShouldNotCreateNodeWhenThereAreNoMoreElements() { var reader = A.Dummy <XmlReader>(); var context = A.Dummy <IParsingContext>(); var parentContext = new FakeParentParsingContext(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = "lorenipsum"); // Se depois do elementParser.ParseAsync o ReadState for EndOfFile significa que não há mais elementos // dentro do elemento atual A.CallTo(() => reader.ReadState).Returns(ReadState.EndOfFile); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldBeEmpty(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .MustHaveHappenedOnceExactly(); }
public async Task TextParsing() { using var reader = Helper.CreateReader("<t>Pindamonhangaba</t>"); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); var textParser = A.Fake <ITextParser>(i => i.Strict()); A.CallTo(() => textParser.Parse(reader, context, "Pindamonhangaba")).Returns("Formatado"); var settings = FakeSettings(textParser); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.When.Should().BeNull(); parentContext.While.Should().BeNull(); parentContext.Nodes.Should().BeEmpty(); parentContext.ParsedText.Should().Be("Formatado"); }
public async Task ShouldSetHasMood() { var reader = A.Dummy <XmlReader>(); var parentContext = new FakeParentParsingContext(); var sceneContext = A.Fake <IParsingSceneContext>(i => i.Strict()); A.CallTo(() => sceneContext.HasMood).Returns(false); A.CallToSet(() => sceneContext.HasMood).To(true).DoesNothing(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.SceneContext).Returns(sceneContext); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.GetArgument <IParentParsingContext>(2).ParsedText = "Happy"); await sut.ParseAsync(reader, context, parentContext); A.CallToSet(() => sceneContext.HasMood).To(true).MustHaveHappenedOnceExactly(); }
public async Task ShouldNotCreateNodeWhenThereAreNoAggregatableElements() { var reader = A.Dummy <XmlReader>(); var context = A.Dummy <IParsingContext>(); var parentContext = new FakeParentParsingContext(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = "lorenipsum"); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .DoesNothing(); await sut.ParseAsync(reader, context, parentContext); parentContext.ShouldBeEmpty(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .MustHaveHappenedOnceExactly(); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .MustHaveHappenedOnceExactly(); }
public async Task NonRepeat() { const string message = "Elemento repetido: a"; using var reader = Helper.CreateReader("<t><a /><a /></t>"); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.LogError(reader, message)).DoesNothing(); var node = A.Dummy <INode>(); var settings = FakeSettings(new FakeNodeParser("a", node)); A.CallTo(() => settings.NoRepeatNode).Returns(true); A.CallTo(() => settings.ExitOnUnknownNode).Returns(false); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); A.CallTo(() => context.LogError(reader, message)).MustHaveHappenedOnceExactly(); }
public async Task ElementParsing(string xml, bool hasA, bool hasB) { using var reader = Helper.CreateReader(xml); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.IsSuccess).Returns(true); var aNode = A.Dummy <INode>(); var bNode = A.Dummy <INode>(); var settings = FakeSettings( new FakeNodeParser("a", aNode), new FakeNodeParser("b", bNode) ); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.ParsedText.Should().BeNull(); parentContext.When.Should().BeNull(); parentContext.While.Should().BeNull(); if (hasA) { parentContext.Nodes.Should().Contain(aNode); parentContext.Nodes.Remove(aNode); } if (hasB) { parentContext.Nodes.Should().Contain(bNode); parentContext.Nodes.Remove(bNode); } parentContext.Nodes.Should().BeEmpty(); }
public async Task ShouldResetSceneParsingContext() { var reader = A.Dummy <XmlReader>(); var parentContext = new FakeParentParsingContext(); var sceneContext = A.Fake <IParsingSceneContext>(i => i.Strict()); A.CallTo(() => sceneContext.Reset()).DoesNothing(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.SceneContext).Returns(sceneContext); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings)) .Invokes(i => i.Arguments.Get <IParentParsingContext>(2).ParsedText = "abc"); A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.AggregationSettings)) .DoesNothing(); await sut.ParseAsync(reader, context, parentContext); A.CallTo(() => context.SceneContext).MustHaveHappenedOnceExactly(); }
public async Task UnconfiguredAttribute() { const string whenMessage = "Atributo não reconhecido: when"; const string whileMessage = "Atributo não reconhecido: while"; using var reader = Helper.CreateReader("<teste when=\"1\" while=\"0\" />"); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.LogError(reader, whenMessage)).DoesNothing(); A.CallTo(() => context.LogError(reader, whileMessage)).DoesNothing(); var settings = A.Dummy <IElementParserSettings>(); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.When.Should().BeNull(); parentContext.While.Should().BeNull(); A.CallTo(() => context.LogError(reader, whenMessage)).MustHaveHappenedOnceExactly(); A.CallTo(() => context.LogError(reader, whileMessage)).MustHaveHappenedOnceExactly(); }
public async Task UnconfiguredElement() { const string aMessage = "Elemento não reconhecido: a"; const string bMessage = "Elemento não reconhecido: b"; using var reader = Helper.CreateReader("<t><a /><b /><c /></t>"); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.LogError(reader, aMessage)).DoesNothing(); A.CallTo(() => context.LogError(reader, bMessage)).DoesNothing(); var node = A.Dummy <INode>(); var settings = FakeSettings(new FakeNodeParser("c", node)); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.Nodes.Single().Should().BeSameAs(node); A.CallTo(() => context.LogError(reader, aMessage)).MustHaveHappenedOnceExactly(); A.CallTo(() => context.LogError(reader, bMessage)).MustHaveHappenedOnceExactly(); }
public async Task TextAndElementSimultaneouslyIsNotAllowed(string xml, bool textFirst) { const string message = "Não é permitido texto dentro de elemento que tenha elementos filhos."; using var reader = Helper.CreateReader(xml); var parentContext = new FakeParentParsingContext(); var context = A.Fake <IParsingContext>(i => i.Strict()); A.CallTo(() => context.LogError(reader, message)).DoesNothing(); var textParser = A.Fake <ITextParser>(i => i.Strict()); A.CallTo(() => textParser.Parse(reader, context, "abc")).Returns("def"); var node = A.Dummy <INode>(); var settings = FakeSettings(textParser, new FakeNodeParser("a", node)); var sut = new ElementParser(); await sut.ParseAsync(reader, context, parentContext, settings); parentContext.When.Should().BeNull(); parentContext.While.Should().BeNull(); if (textFirst) { parentContext.Nodes.Should().BeEmpty(); parentContext.ParsedText.Should().Be("def"); } else { parentContext.ShouldContainSingle(node); parentContext.ParsedText.Should().BeNull(); } A.CallTo(() => context.LogError(reader, message)).MustHaveHappenedOnceExactly(); }