Ejemplo n.º 1
0
    public async Task Empty()
    {
        using var reader = Helper.CreateReader("<teste />");
        var context       = A.Fake <IParsingContext>(i => i.Strict());
        var settings      = A.Fake <IElementParserSettings>(i => i.Strict());
        var parentContext = A.Fake <IParentParsingContext>(i => i.Strict());

        var sut = new ElementParser();
        await sut.ParseAsync(reader, context, parentContext, settings);
    }
Ejemplo n.º 2
0
    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);
    }
Ejemplo n.º 3
0
    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();
    }
Ejemplo n.º 4
0
    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");
    }
Ejemplo n.º 5
0
    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();
    }
Ejemplo n.º 6
0
    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();
        }
    }
Ejemplo n.º 7
0
    public async Task WithAggregateSettingsWithoutTextParserShouldReturnWhenTextIsFound()
    {
        var reader = A.Fake <XmlReader>(i => i.Strict());

        A.CallTo(() => reader.ReadState).Returns(ReadState.Interactive);
        A.CallTo(() => reader.NodeType).Returns(XmlNodeType.Text);

        var parentContext = A.Fake <IParentParsingContext>(i => i.Strict());
        var context       = A.Fake <IParsingContext>(i => i.Strict());

        var settings = A.Fake <IElementParserSettings>(i => i.Strict());

        A.CallTo(() => settings.TextParser).Returns(null);
        A.CallTo(() => settings.NoRepeatNode).Returns(false);
        A.CallTo(() => settings.ExitOnUnknownNode).Returns(true);

        var sut = new ElementParser();

        await sut.ParseAsync(reader, context, parentContext, settings);
    }
Ejemplo n.º 8
0
    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");
    }
Ejemplo n.º 9
0
    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();
    }
Ejemplo n.º 10
0
    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();
    }
Ejemplo n.º 11
0
    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();
    }
Ejemplo n.º 12
0
    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();
    }
Ejemplo n.º 13
0
    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();
    }