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