Ejemplo n.º 1
0
def test_parse_table():

    parser = Parser([
        (1, gherkin.TOKEN_TABLE_COLUMN, 'name'),
        (1, gherkin.TOKEN_TABLE_COLUMN, 'email'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_TABLE_COLUMN, 'Lincoln'),
        (2, gherkin.TOKEN_TABLE_COLUMN, '*****@*****.**'),
        (2, gherkin.TOKEN_NEWLINE, '\n'),
        (3, gherkin.TOKEN_TABLE_COLUMN, 'Gabriel'),
        (3, gherkin.TOKEN_TABLE_COLUMN, '*****@*****.**'),
        (3, gherkin.TOKEN_NEWLINE, '\n'),
        (4, gherkin.TOKEN_LABEL, 'Scenario'),
        (4, gherkin.TOKEN_EOF, ''),
    ])

    feature = parser.parse_table()

    feature.should.equal(
        Ast.Table(line=1,
                  fields=[
                      ['name', 'email'],
                      ['Lincoln', '*****@*****.**'],
                      ['Gabriel', '*****@*****.**'],
                  ]))
Ejemplo n.º 2
0
def test_parse_empty_title():

    parser = Parser([(1, gherkin.TOKEN_NEWLINE, "\n"), (2, gherkin.TOKEN_TEXT, "more text after title")])

    feature = parser.parse_title()

    feature.should.be.none
Ejemplo n.º 3
0
def teste_parse_scenario_with_description():

    parser = Parser(
        [
            (1, gherkin.TOKEN_LABEL, "Scenario"),
            (1, gherkin.TOKEN_TEXT, "Scenario title"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_TEXT, "Scenario description"),
            (2, gherkin.TOKEN_TEXT, "More description"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_TEXT, "Given first step"),
        ]
    )

    feature = parser.parse_scenarios()

    feature.should.equal(
        [
            Ast.Scenario(
                line=1,
                title=Ast.Text(line=1, text="Scenario title"),
                description=Ast.Text(line=2, text="Scenario description More description"),
                steps=[Ast.Step(line=3, title=Ast.Text(line=3, text="Given first step"))],
            )
        ]
    )
Ejemplo n.º 4
0
def test_parse_table():

    parser = Parser(
        [
            (1, gherkin.TOKEN_TABLE_COLUMN, "name"),
            (1, gherkin.TOKEN_TABLE_COLUMN, "email"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_TABLE_COLUMN, "Lincoln"),
            (2, gherkin.TOKEN_TABLE_COLUMN, "*****@*****.**"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_TABLE_COLUMN, "Gabriel"),
            (3, gherkin.TOKEN_TABLE_COLUMN, "*****@*****.**"),
            (3, gherkin.TOKEN_NEWLINE, "\n"),
            (4, gherkin.TOKEN_LABEL, "Scenario"),
            (4, gherkin.TOKEN_EOF, ""),
        ]
    )

    feature = parser.parse_table()

    feature.should.equal(
        Ast.Table(
            line=1, fields=[["name", "email"], ["Lincoln", "*****@*****.**"], ["Gabriel", "*****@*****.**"]]
        )
    )
Ejemplo n.º 5
0
def teste_parse_scenario_with_description():

    parser = Parser([
        (1, gherkin.TOKEN_LABEL, 'Scenario'),
        (1, gherkin.TOKEN_TEXT, 'Scenario title'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_TEXT, 'Scenario description'),
        (2, gherkin.TOKEN_TEXT, 'More description'),
        (2, gherkin.TOKEN_NEWLINE, '\n'),
        (3, gherkin.TOKEN_TEXT, 'Given first step'),
    ])

    feature = parser.parse_scenarios()

    feature.should.equal([
        Ast.Scenario(
            line=1,
            title=Ast.Text(line=1, text='Scenario title'),
            description=Ast.Text(line=2,
                                 text='Scenario description More description'),
            steps=[
                Ast.Step(line=3,
                         title=Ast.Text(line=3, text='Given first step'))
            ],
        )
    ])
Ejemplo n.º 6
0
def test_parse_tags_on_scenario_outline_examples():
    "Parser should allow tags to be defined in examples"

    # Given a parser loaded with a document that contains tags on
    # scenario outline examples
    #   @tagged-feature
    #   Feature: Parse tags
    #   @tag1 @tag2
    #   Scenario Outline: Test
    #   @example-tag1
    #   @example-tag2
    #   Examples:
    #     | Header |

    parser = Parser(
        [
            (1, gherkin.TOKEN_TAG, "tagged-feature"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_LABEL, "Feature"),
            (2, gherkin.TOKEN_TEXT, "Parse tags"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_TAG, "tag1"),
            (3, gherkin.TOKEN_TAG, "tag2"),
            (3, gherkin.TOKEN_NEWLINE, "\n"),
            (4, gherkin.TOKEN_LABEL, "Scenario Outline"),
            (4, gherkin.TOKEN_TEXT, "Test"),
            (4, gherkin.TOKEN_NEWLINE, "\n"),
            (5, gherkin.TOKEN_TAG, "example-tag1"),
            (5, gherkin.TOKEN_NEWLINE, "\n"),
            (6, gherkin.TOKEN_TAG, "example-tag2"),
            (6, gherkin.TOKEN_NEWLINE, "\n"),
            (7, gherkin.TOKEN_LABEL, "Examples"),
            (7, gherkin.TOKEN_NEWLINE, "\n"),
            (8, gherkin.TOKEN_TABLE_COLUMN, "Header"),
            (8, gherkin.TOKEN_NEWLINE, "\n"),
            (9, gherkin.TOKEN_EOF, ""),
        ]
    )

    # When I parse the document
    feature = parser.parse_feature()

    # Then I see all the tags were found
    feature.should.equal(
        Ast.Feature(
            line=2,
            title=Ast.Text(line=2, text="Parse tags"),
            tags=["tagged-feature"],
            scenarios=[
                Ast.ScenarioOutline(
                    line=4,
                    title=Ast.Text(line=4, text="Test"),
                    tags=["tag1", "tag2"],
                    examples=Ast.Examples(
                        line=7, tags=["example-tag1", "example-tag2"], table=Ast.Table(line=8, fields=[["Header"]])
                    ),
                )
            ],
        )
    )
Ejemplo n.º 7
0
def test_parse_metadata():

    parser = Parser([(1, gherkin.TOKEN_META_LABEL, "language"), (1, gherkin.TOKEN_META_VALUE, "pt-br")])

    metadata = parser.parse_metadata()

    metadata.should.equal(Ast.Metadata(line=1, key="language", value="pt-br"))
Ejemplo n.º 8
0
def test_parse_title():

    parser = Parser([(1, gherkin.TOKEN_TEXT, "Scenario title"), (1, gherkin.TOKEN_NEWLINE, "\n")])

    feature = parser.parse_title()

    feature.should.equal(Ast.Text(line=1, text="Scenario title"))
Ejemplo n.º 9
0
def test_parse_feature():

    parser = Parser(
        [
            (1, gherkin.TOKEN_LABEL, "Feature"),
            (1, gherkin.TOKEN_TEXT, "Feature title"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_TEXT, "feature description"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_LABEL, "Background"),
            (3, gherkin.TOKEN_TEXT, "Some background"),
            (3, gherkin.TOKEN_NEWLINE, "\n"),
            (4, gherkin.TOKEN_TEXT, "Given the problem"),
            (4, gherkin.TOKEN_NEWLINE, "\n"),
            (5, gherkin.TOKEN_LABEL, "Scenario"),
            (5, gherkin.TOKEN_TEXT, "Scenario title"),
            (5, gherkin.TOKEN_NEWLINE, "\n"),
            (6, gherkin.TOKEN_TEXT, "Given first step"),
            (6, gherkin.TOKEN_NEWLINE, "\n"),
            (7, gherkin.TOKEN_LABEL, "Scenario"),
            (7, gherkin.TOKEN_TEXT, "Another scenario"),
            (7, gherkin.TOKEN_NEWLINE, "\n"),
            (8, gherkin.TOKEN_TEXT, "Given this step"),
            (8, gherkin.TOKEN_NEWLINE, "\n"),
            (9, gherkin.TOKEN_TEXT, "When we take another step"),
            (9, gherkin.TOKEN_NEWLINE, "\n"),
            (10, gherkin.TOKEN_EOF, ""),
        ]
    )

    feature = parser.parse_feature()

    feature.should.equal(
        Ast.Feature(
            line=1,
            title=Ast.Text(line=1, text="Feature title"),
            description=Ast.Text(line=2, text="feature description"),
            background=Ast.Background(
                line=3,
                title=Ast.Text(line=3, text="Some background"),
                steps=[Ast.Step(line=4, title=Ast.Text(line=4, text="Given the problem"))],
            ),
            scenarios=[
                Ast.Scenario(
                    line=5,
                    title=Ast.Text(line=5, text="Scenario title"),
                    steps=[Ast.Step(line=6, title=Ast.Text(line=6, text="Given first step"))],
                ),
                Ast.Scenario(
                    line=7,
                    title=Ast.Text(line=7, text="Another scenario"),
                    steps=[
                        Ast.Step(line=8, title=Ast.Text(line=8, text="Given this step")),
                        Ast.Step(line=9, title=Ast.Text(line=9, text="When we take another step")),
                    ],
                ),
            ],
        )
    )
Ejemplo n.º 10
0
def test_parse_metadata_incomplete():

    parser = Parser([
        (1, gherkin.TOKEN_META_LABEL, 'language'),
        (1, gherkin.TOKEN_EOF, ''),
    ])

    parser.parse_metadata().should.be.none
Ejemplo n.º 11
0
def test_parse_quoted_strings_on_steps():

    # Given a parser loaded with the following Gherkin document
    #    Given the following email template:
    #       '''Here we go with a pretty
    #       big block of text
    #       surrounded by triple quoted strings
    #       '''
    #    And a cat picture
    #       """Now notice we didn't use (:) above
    #       """
    parser = Parser(
        [
            (1, gherkin.TOKEN_LABEL, "Given the following email template"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_QUOTES, "'''"),
            (
                2,
                gherkin.TOKEN_TEXT,
                """Here we go with a pretty
       big block of text
       surrounded by triple quoted strings
       """,
            ),
            (5, gherkin.TOKEN_QUOTES, "'''"),
            (5, gherkin.TOKEN_NEWLINE, "\n"),
            (6, gherkin.TOKEN_TEXT, "And a cat picture"),
            (6, gherkin.TOKEN_NEWLINE, "\n"),
            (7, gherkin.TOKEN_QUOTES, '"""'),
            (7, gherkin.TOKEN_TEXT, "Now notice we didn't use (:) above\n       "),
            (8, gherkin.TOKEN_QUOTES, '"""'),
            (8, gherkin.TOKEN_NEWLINE, "\n"),
            (9, gherkin.TOKEN_EOF, ""),
        ]
    )

    steps = parser.parse_steps()

    steps.should.equal(
        [
            Ast.Step(
                line=1,
                title=Ast.Text(line=1, text="Given the following email template"),
                text=Ast.Text(
                    line=2,
                    text="""Here we go with a pretty
       big block of text
       surrounded by triple quoted strings
       """,
                ),
            ),
            Ast.Step(
                line=6,
                title=Ast.Text(line=6, text="And a cat picture"),
                text=Ast.Text(line=7, text="Now notice we didn't use (:) above\n       "),
            ),
        ]
    )
Ejemplo n.º 12
0
def test_parse_tags_on_scenario_outline_examples():
    "Parser should allow tags to be defined in examples"

    # Given a parser loaded with a document that contains tags on
    # scenario outline examples
    #   @tagged-feature
    #   Feature: Parse tags
    #   @tag1 @tag2
    #   Scenario Outline: Test
    #   @example-tag1
    #   @example-tag2
    #   Examples:
    #     | Header |

    parser = Parser([
        (1, gherkin.TOKEN_TAG, 'tagged-feature'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_LABEL, 'Feature'),
        (2, gherkin.TOKEN_TEXT, 'Parse tags'),
        (2, gherkin.TOKEN_NEWLINE, '\n'),
        (3, gherkin.TOKEN_TAG, 'tag1'),
        (3, gherkin.TOKEN_TAG, 'tag2'),
        (3, gherkin.TOKEN_NEWLINE, '\n'),
        (4, gherkin.TOKEN_LABEL, 'Scenario Outline'),
        (4, gherkin.TOKEN_TEXT, 'Test'),
        (4, gherkin.TOKEN_NEWLINE, '\n'),
        (5, gherkin.TOKEN_TAG, 'example-tag1'),
        (5, gherkin.TOKEN_NEWLINE, '\n'),
        (6, gherkin.TOKEN_TAG, 'example-tag2'),
        (6, gherkin.TOKEN_NEWLINE, '\n'),
        (7, gherkin.TOKEN_LABEL, 'Examples'),
        (7, gherkin.TOKEN_NEWLINE, '\n'),
        (8, gherkin.TOKEN_TABLE_COLUMN, 'Header'),
        (8, gherkin.TOKEN_NEWLINE, '\n'),
        (9, gherkin.TOKEN_EOF, ''),
    ])

    # When I parse the document
    feature = parser.parse_feature()

    # Then I see all the tags were found
    feature.should.equal(
        Ast.Feature(line=2,
                    title=Ast.Text(line=2, text='Parse tags'),
                    tags=['tagged-feature'],
                    scenarios=[
                        Ast.ScenarioOutline(
                            line=4,
                            title=Ast.Text(line=4, text='Test'),
                            tags=['tag1', 'tag2'],
                            examples=Ast.Examples(
                                line=7,
                                tags=['example-tag1', 'example-tag2'],
                                table=Ast.Table(line=8, fields=[['Header']])),
                        )
                    ]))
Ejemplo n.º 13
0
def test_parse_title():

    parser = Parser([
        (1, gherkin.TOKEN_TEXT, 'Scenario title'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
    ])

    feature = parser.parse_title()

    feature.should.equal(Ast.Text(line=1, text='Scenario title'))
Ejemplo n.º 14
0
def test_parse_empty_title():

    parser = Parser([
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_TEXT, 'more text after title'),
    ])

    feature = parser.parse_title()

    feature.should.be.none
Ejemplo n.º 15
0
def test_parse_metadata():

    parser = Parser([
        (1, gherkin.TOKEN_META_LABEL, 'language'),
        (1, gherkin.TOKEN_META_VALUE, 'pt-br'),
    ])

    metadata = parser.parse_metadata()

    metadata.should.equal(Ast.Metadata(line=1, key='language', value='pt-br'))
Ejemplo n.º 16
0
def test_parse_background():

    # Background: title
    #  Given two users in the database:
    #    | name | email |
    #    | Lincoln | [email protected] |
    #    | Gabriel | [email protected] |
    # Scenario:
    parser = Parser(
        [
            (1, gherkin.TOKEN_LABEL, "Background"),
            (1, gherkin.TOKEN_TEXT, "title"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_LABEL, "Given two users in the database"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_TABLE_COLUMN, "name"),
            (3, gherkin.TOKEN_TABLE_COLUMN, "email"),
            (3, gherkin.TOKEN_NEWLINE, "\n"),
            (4, gherkin.TOKEN_TABLE_COLUMN, "Lincoln"),
            (4, gherkin.TOKEN_TABLE_COLUMN, "*****@*****.**"),
            (4, gherkin.TOKEN_NEWLINE, "\n"),
            (5, gherkin.TOKEN_TABLE_COLUMN, "Gabriel"),
            (5, gherkin.TOKEN_TABLE_COLUMN, "*****@*****.**"),
            (5, gherkin.TOKEN_NEWLINE, "\n"),
            (6, gherkin.TOKEN_LABEL, "Scenario"),
        ]
    )

    # When the background is parsed
    feature = parser.parse_background()

    # Then I see the output contains a valid background with a step
    # with examples. Notice the scenario label is not returned
    # anywhere here
    feature.should.equal(
        Ast.Background(
            line=1,
            title=Ast.Text(line=1, text="title"),
            steps=[
                Ast.Step(
                    line=2,
                    title=Ast.Text(line=2, text="Given two users in the database"),
                    table=Ast.Table(
                        line=3,
                        fields=[
                            ["name", "email"],
                            ["Lincoln", "*****@*****.**"],
                            ["Gabriel", "*****@*****.**"],
                        ],
                    ),
                )
            ],
        )
    )
Ejemplo n.º 17
0
def test_parse_text():
    parser = Parser([
        (1, gherkin.TOKEN_TAG, 'tag1'),
        (1, gherkin.TOKEN_TAG, 'tag2'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_TAG, 'tag3'),
        (2, gherkin.TOKEN_NEWLINE, '\n'),
        (3, gherkin.TOKEN_LABEL, 'Feature'),
    ])

    tags = parser.parse_tags()

    tags.should.equal(['tag1', 'tag2', 'tag3'])
Ejemplo n.º 18
0
def test_parse_text():
    parser = Parser(
        [
            (1, gherkin.TOKEN_TAG, "tag1"),
            (1, gherkin.TOKEN_TAG, "tag2"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_TAG, "tag3"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_LABEL, "Feature"),
        ]
    )

    tags = parser.parse_tags()

    tags.should.equal(["tag1", "tag2", "tag3"])
Ejemplo n.º 19
0
def test_parse_background():

    # Background: title
    #  Given two users in the database:
    #    | name | email |
    #    | Lincoln | [email protected] |
    #    | Gabriel | [email protected] |
    # Scenario:
    parser = Parser([
        (1, gherkin.TOKEN_LABEL, 'Background'),
        (1, gherkin.TOKEN_TEXT, 'title'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_LABEL, 'Given two users in the database'),
        (2, gherkin.TOKEN_NEWLINE, '\n'),
        (3, gherkin.TOKEN_TABLE_COLUMN, 'name'),
        (3, gherkin.TOKEN_TABLE_COLUMN, 'email'),
        (3, gherkin.TOKEN_NEWLINE, '\n'),
        (4, gherkin.TOKEN_TABLE_COLUMN, 'Lincoln'),
        (4, gherkin.TOKEN_TABLE_COLUMN, '*****@*****.**'),
        (4, gherkin.TOKEN_NEWLINE, '\n'),
        (5, gherkin.TOKEN_TABLE_COLUMN, 'Gabriel'),
        (5, gherkin.TOKEN_TABLE_COLUMN, '*****@*****.**'),
        (5, gherkin.TOKEN_NEWLINE, '\n'),
        (6, gherkin.TOKEN_LABEL, 'Scenario'),
    ])

    # When the background is parsed
    feature = parser.parse_background()

    # Then I see the output contains a valid background with a step
    # with examples. Notice the scenario label is not returned
    # anywhere here
    feature.should.equal(
        Ast.Background(
            line=1,
            title=Ast.Text(line=1, text='title'),
            steps=[
                Ast.Step(
                    line=2,
                    title=Ast.Text(line=2,
                                   text='Given two users in the database'),
                    table=Ast.Table(line=3,
                                    fields=[
                                        ['name', 'email'],
                                        ['Lincoln', '*****@*****.**'],
                                        ['Gabriel', '*****@*****.**'],
                                    ]))
            ]))
Ejemplo n.º 20
0
def test_parse_metadata_syntax_error():

    parser = Parser([
        (1, gherkin.TOKEN_META_LABEL, 'language'),
        (1, gherkin.TOKEN_TEXT, 'pt-br'),
    ])

    parser.parse_metadata.when.called.should.throw(
        SyntaxError, 'No value found for the meta-field `language\'')
Ejemplo n.º 21
0
def test_parse_quoted_strings_on_steps():

    # Given a parser loaded with the following Gherkin document
    #    Given the following email template:
    #       '''Here we go with a pretty
    #       big block of text
    #       surrounded by triple quoted strings
    #       '''
    #    And a cat picture
    #       """Now notice we didn't use (:) above
    #       """
    parser = Parser([
        (1, gherkin.TOKEN_LABEL, 'Given the following email template'),
        (1, gherkin.TOKEN_NEWLINE, '\n'), (2, gherkin.TOKEN_QUOTES, "'''"),
        (2, gherkin.TOKEN_TEXT, '''Here we go with a pretty
       big block of text
       surrounded by triple quoted strings
       '''), (5, gherkin.TOKEN_QUOTES, "'''"),
        (5, gherkin.TOKEN_NEWLINE, '\n'),
        (6, gherkin.TOKEN_TEXT, 'And a cat picture'),
        (6, gherkin.TOKEN_NEWLINE, '\n'), (7, gherkin.TOKEN_QUOTES, '"""'),
        (7, gherkin.TOKEN_TEXT, "Now notice we didn't use (:) above\n       "),
        (8, gherkin.TOKEN_QUOTES, '"""'), (8, gherkin.TOKEN_NEWLINE, '\n'),
        (9, gherkin.TOKEN_EOF, '')
    ])

    steps = parser.parse_steps()

    steps.should.equal([
        Ast.Step(line=1,
                 title=Ast.Text(line=1,
                                text='Given the following email template'),
                 text=Ast.Text(line=2,
                               text='''Here we go with a pretty
       big block of text
       surrounded by triple quoted strings
       ''')),
        Ast.Step(line=6,
                 title=Ast.Text(line=6, text='And a cat picture'),
                 text=Ast.Text(
                     line=7,
                     text="Now notice we didn't use (:) above\n       "))
    ])
Ejemplo n.º 22
0
def test_parse_tags_on_feature_and_scenario():

    # Given a parser loaded with a gherkin document with one tag on
    # the feature and two tags on a scenario:
    #
    #   @tagged-feature
    #   Feature: Parse tags
    #
    #   @tag1 @tag2
    #   Scenario: Test
    parser = Parser(
        [
            (1, gherkin.TOKEN_TAG, "tagged-feature"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_LABEL, "Feature"),
            (2, gherkin.TOKEN_TEXT, "Parse tags"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_NEWLINE, "\n"),
            (4, gherkin.TOKEN_TAG, "tag1"),
            (4, gherkin.TOKEN_TAG, "tag2"),
            (4, gherkin.TOKEN_NEWLINE, "\n"),
            (5, gherkin.TOKEN_LABEL, "Scenario"),
            (5, gherkin.TOKEN_TEXT, "Test"),
            (6, gherkin.TOKEN_NEWLINE, "\n"),
            (7, gherkin.TOKEN_EOF, ""),
        ]
    )

    feature = parser.parse_feature()

    feature.should.equal(
        Ast.Feature(
            line=2,
            title=Ast.Text(line=2, text="Parse tags"),
            tags=["tagged-feature"],
            scenarios=[Ast.Scenario(line=5, title=Ast.Text(line=5, text="Test"), tags=["tag1", "tag2"])],
        )
    )
Ejemplo n.º 23
0
def test_parse_tags_on_feature_and_scenario():

    # Given a parser loaded with a gherkin document with one tag on
    # the feature and two tags on a scenario:
    #
    #   @tagged-feature
    #   Feature: Parse tags
    #
    #   @tag1 @tag2
    #   Scenario: Test
    parser = Parser([
        (1, gherkin.TOKEN_TAG, 'tagged-feature'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_LABEL, 'Feature'),
        (2, gherkin.TOKEN_TEXT, 'Parse tags'),
        (2, gherkin.TOKEN_NEWLINE, '\n'),
        (3, gherkin.TOKEN_NEWLINE, '\n'),
        (4, gherkin.TOKEN_TAG, 'tag1'),
        (4, gherkin.TOKEN_TAG, 'tag2'),
        (4, gherkin.TOKEN_NEWLINE, '\n'),
        (5, gherkin.TOKEN_LABEL, 'Scenario'),
        (5, gherkin.TOKEN_TEXT, 'Test'),
        (6, gherkin.TOKEN_NEWLINE, '\n'),
        (7, gherkin.TOKEN_EOF, ''),
    ])

    feature = parser.parse_feature()

    feature.should.equal(
        Ast.Feature(line=2,
                    title=Ast.Text(line=2, text='Parse tags'),
                    tags=['tagged-feature'],
                    scenarios=[
                        Ast.Scenario(line=5,
                                     title=Ast.Text(line=5, text='Test'),
                                     tags=['tag1', 'tag2'])
                    ]))
Ejemplo n.º 24
0
def test_parse_scenario_outline_with_examples():
    ""

    # Given a parser loaded with the following gherkin document:
    #
    #     Scenario Outline: Plant a tree
    #       Given the <name> of a garden
    #       When I plant a tree
    #        And wait for <num_days> days
    #       Then I see it growing
    #     Examples:
    #       | name | num_days |
    #       | Secret | 2 |
    #       | Octopus | 5 |
    parser = Parser([(1, gherkin.TOKEN_LABEL, 'Scenario Outline'),
                     (1, gherkin.TOKEN_TEXT, 'Plant a tree'),
                     (1, gherkin.TOKEN_NEWLINE, '\n'),
                     (2, gherkin.TOKEN_TEXT, 'Given the <name> of a garden'),
                     (2, gherkin.TOKEN_NEWLINE, '\n'),
                     (3, gherkin.TOKEN_TEXT, 'When I plant a tree'),
                     (3, gherkin.TOKEN_NEWLINE, '\n'),
                     (4, gherkin.TOKEN_TEXT, 'And wait for <num_days> days'),
                     (4, gherkin.TOKEN_NEWLINE, '\n'),
                     (5, gherkin.TOKEN_TEXT, 'Then I see it growing'),
                     (5, gherkin.TOKEN_NEWLINE, '\n'),
                     (6, gherkin.TOKEN_LABEL, 'Examples'),
                     (6, gherkin.TOKEN_NEWLINE, '\n'),
                     (7, gherkin.TOKEN_TABLE_COLUMN, 'name'),
                     (7, gherkin.TOKEN_TABLE_COLUMN, 'num_days'),
                     (7, gherkin.TOKEN_NEWLINE, '\n'),
                     (8, gherkin.TOKEN_TABLE_COLUMN, 'Secret'),
                     (8, gherkin.TOKEN_TABLE_COLUMN, '2'),
                     (8, gherkin.TOKEN_NEWLINE, '\n'),
                     (9, gherkin.TOKEN_TABLE_COLUMN, 'Octopus'),
                     (9, gherkin.TOKEN_TABLE_COLUMN, '5'),
                     (9, gherkin.TOKEN_NEWLINE, '\n'),
                     (10, gherkin.TOKEN_EOF, '')])

    scenarios = parser.parse_scenarios()

    scenarios.should.equal([
        Ast.ScenarioOutline(
            line=1,
            title=Ast.Text(line=1, text='Plant a tree'),
            steps=[
                Ast.Step(line=2,
                         title=Ast.Text(line=2,
                                        text='Given the <name> of a garden')),
                Ast.Step(line=3,
                         title=Ast.Text(line=3, text='When I plant a tree')),
                Ast.Step(line=4,
                         title=Ast.Text(line=4,
                                        text='And wait for <num_days> days')),
                Ast.Step(line=5,
                         title=Ast.Text(line=5, text='Then I see it growing'))
            ],
            examples=Ast.Examples(line=6,
                                  table=Ast.Table(line=7,
                                                  fields=[
                                                      ['name', 'num_days'],
                                                      ['Secret', '2'],
                                                      ['Octopus', '5'],
                                                  ])))
    ])
Ejemplo n.º 25
0
def test_parse_metadata_empty():

    Parser([(1, gherkin.TOKEN_EOF, '')]).parse_metadata().should.be.none

    Parser([None]).parse_metadata().should.be.none
Ejemplo n.º 26
0
def test_parse_metadata_incomplete():

    parser = Parser([(1, gherkin.TOKEN_META_LABEL, "language"), (1, gherkin.TOKEN_EOF, "")])

    parser.parse_metadata().should.be.none
Ejemplo n.º 27
0
def test_parse_scenario_outline_with_examples():
    ""

    # Given a parser loaded with the following gherkin document:
    #
    #     Scenario Outline: Plant a tree
    #       Given the <name> of a garden
    #       When I plant a tree
    #        And wait for <num_days> days
    #       Then I see it growing
    #     Examples:
    #       | name | num_days |
    #       | Secret | 2 |
    #       | Octopus | 5 |
    parser = Parser(
        [
            (1, gherkin.TOKEN_LABEL, "Scenario Outline"),
            (1, gherkin.TOKEN_TEXT, "Plant a tree"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_TEXT, "Given the <name> of a garden"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_TEXT, "When I plant a tree"),
            (3, gherkin.TOKEN_NEWLINE, "\n"),
            (4, gherkin.TOKEN_TEXT, "And wait for <num_days> days"),
            (4, gherkin.TOKEN_NEWLINE, "\n"),
            (5, gherkin.TOKEN_TEXT, "Then I see it growing"),
            (5, gherkin.TOKEN_NEWLINE, "\n"),
            (6, gherkin.TOKEN_LABEL, "Examples"),
            (6, gherkin.TOKEN_NEWLINE, "\n"),
            (7, gherkin.TOKEN_TABLE_COLUMN, "name"),
            (7, gherkin.TOKEN_TABLE_COLUMN, "num_days"),
            (7, gherkin.TOKEN_NEWLINE, "\n"),
            (8, gherkin.TOKEN_TABLE_COLUMN, "Secret"),
            (8, gherkin.TOKEN_TABLE_COLUMN, "2"),
            (8, gherkin.TOKEN_NEWLINE, "\n"),
            (9, gherkin.TOKEN_TABLE_COLUMN, "Octopus"),
            (9, gherkin.TOKEN_TABLE_COLUMN, "5"),
            (9, gherkin.TOKEN_NEWLINE, "\n"),
            (10, gherkin.TOKEN_EOF, ""),
        ]
    )

    scenarios = parser.parse_scenarios()

    scenarios.should.equal(
        [
            Ast.ScenarioOutline(
                line=1,
                title=Ast.Text(line=1, text="Plant a tree"),
                steps=[
                    Ast.Step(line=2, title=Ast.Text(line=2, text="Given the <name> of a garden")),
                    Ast.Step(line=3, title=Ast.Text(line=3, text="When I plant a tree")),
                    Ast.Step(line=4, title=Ast.Text(line=4, text="And wait for <num_days> days")),
                    Ast.Step(line=5, title=Ast.Text(line=5, text="Then I see it growing")),
                ],
                examples=Ast.Examples(
                    line=6, table=Ast.Table(line=7, fields=[["name", "num_days"], ["Secret", "2"], ["Octopus", "5"]])
                ),
            )
        ]
    )
Ejemplo n.º 28
0
def test_parse_feature():

    parser = Parser([
        (1, gherkin.TOKEN_LABEL, 'Feature'),
        (1, gherkin.TOKEN_TEXT, 'Feature title'),
        (1, gherkin.TOKEN_NEWLINE, '\n'),
        (2, gherkin.TOKEN_TEXT, 'feature description'),
        (2, gherkin.TOKEN_NEWLINE, '\n'),
        (3, gherkin.TOKEN_LABEL, 'Background'),
        (3, gherkin.TOKEN_TEXT, 'Some background'),
        (3, gherkin.TOKEN_NEWLINE, '\n'),
        (4, gherkin.TOKEN_TEXT, 'Given the problem'),
        (4, gherkin.TOKEN_NEWLINE, '\n'),
        (5, gherkin.TOKEN_LABEL, 'Scenario'),
        (5, gherkin.TOKEN_TEXT, 'Scenario title'),
        (5, gherkin.TOKEN_NEWLINE, '\n'),
        (6, gherkin.TOKEN_TEXT, 'Given first step'),
        (6, gherkin.TOKEN_NEWLINE, '\n'),
        (7, gherkin.TOKEN_LABEL, 'Scenario'),
        (7, gherkin.TOKEN_TEXT, 'Another scenario'),
        (7, gherkin.TOKEN_NEWLINE, '\n'),
        (8, gherkin.TOKEN_TEXT, 'Given this step'),
        (8, gherkin.TOKEN_NEWLINE, '\n'),
        (9, gherkin.TOKEN_TEXT, 'When we take another step'),
        (9, gherkin.TOKEN_NEWLINE, '\n'),
        (10, gherkin.TOKEN_EOF, ''),
    ])

    feature = parser.parse_feature()

    feature.should.equal(
        Ast.Feature(
            line=1,
            title=Ast.Text(line=1, text='Feature title'),
            description=Ast.Text(line=2, text='feature description'),
            background=Ast.Background(
                line=3,
                title=Ast.Text(line=3, text='Some background'),
                steps=[
                    Ast.Step(line=4,
                             title=Ast.Text(line=4, text='Given the problem'))
                ]),
            scenarios=[
                Ast.Scenario(line=5,
                             title=Ast.Text(line=5, text='Scenario title'),
                             steps=[
                                 Ast.Step(line=6,
                                          title=Ast.Text(
                                              line=6, text='Given first step'))
                             ]),
                Ast.Scenario(
                    line=7,
                    title=Ast.Text(line=7, text='Another scenario'),
                    steps=[
                        Ast.Step(line=8,
                                 title=Ast.Text(line=8,
                                                text='Given this step')),
                        Ast.Step(line=9,
                                 title=Ast.Text(
                                     line=9, text='When we take another step'))
                    ]),
            ],
        ))
Ejemplo n.º 29
0
def test_parse_tables_within_steps():
    "Lexer.run() Should be able to parse example tables from steps"

    # Given a parser loaded with steps that contain example tables
    """Feature: Check models existence
		Background:
	   Given I have a garden in the database:
	      | @name  | area | raining |
	      | Secret Garden | 45   | false   |
	    And I have gardens in the database:
	      | name            | area | raining |
	      | Octopus' Garden | 120  | true    |
         Scenario: Plant a tree
           Given the <name> of a garden
           When I plant a tree
            And wait for <num_days> days
           Then I see it growing
    """
    parser = Parser(
        [
            (1, gherkin.TOKEN_LABEL, "Feature"),
            (1, gherkin.TOKEN_TEXT, "Check models existence"),
            (1, gherkin.TOKEN_NEWLINE, "\n"),
            (2, gherkin.TOKEN_LABEL, "Background"),
            (2, gherkin.TOKEN_NEWLINE, "\n"),
            (3, gherkin.TOKEN_LABEL, "Given I have a garden in the database"),
            (3, gherkin.TOKEN_NEWLINE, "\n"),
            (4, gherkin.TOKEN_TABLE_COLUMN, "@name"),
            (4, gherkin.TOKEN_TABLE_COLUMN, "area"),
            (4, gherkin.TOKEN_TABLE_COLUMN, "raining"),
            (4, gherkin.TOKEN_NEWLINE, "\n"),
            (5, gherkin.TOKEN_TABLE_COLUMN, "Secret Garden"),
            (5, gherkin.TOKEN_TABLE_COLUMN, "45"),
            (5, gherkin.TOKEN_TABLE_COLUMN, "false"),
            (5, gherkin.TOKEN_NEWLINE, "\n"),
            (6, gherkin.TOKEN_LABEL, "And I have gardens in the database"),
            (6, gherkin.TOKEN_NEWLINE, "\n"),
            (7, gherkin.TOKEN_TABLE_COLUMN, "name"),
            (7, gherkin.TOKEN_TABLE_COLUMN, "area"),
            (7, gherkin.TOKEN_TABLE_COLUMN, "raining"),
            (7, gherkin.TOKEN_NEWLINE, "\n"),
            (8, gherkin.TOKEN_TABLE_COLUMN, "Octopus' Garden"),
            (8, gherkin.TOKEN_TABLE_COLUMN, "120"),
            (8, gherkin.TOKEN_TABLE_COLUMN, "true"),
            (8, gherkin.TOKEN_NEWLINE, "\n"),
            (9, gherkin.TOKEN_LABEL, "Scenario"),
            (9, gherkin.TOKEN_TEXT, "Plant a tree"),
            (9, gherkin.TOKEN_NEWLINE, "\n"),
            (10, gherkin.TOKEN_TEXT, "Given the <name> of a garden"),
            (10, gherkin.TOKEN_NEWLINE, "\n"),
            (11, gherkin.TOKEN_TEXT, "When I plant a tree"),
            (11, gherkin.TOKEN_NEWLINE, "\n"),
            (12, gherkin.TOKEN_TEXT, "And wait for <num_days> days"),
            (12, gherkin.TOKEN_NEWLINE, "\n"),
            (13, gherkin.TOKEN_TEXT, "Then I see it growing"),
            (13, gherkin.TOKEN_NEWLINE, "\n"),
            (14, gherkin.TOKEN_EOF, ""),
        ]
    )

    feature = parser.parse_feature()

    feature.should.equal(
        Ast.Feature(
            line=1,
            title=Ast.Text(line=1, text="Check models existence"),
            background=Ast.Background(
                line=2,
                steps=[
                    Ast.Step(
                        line=3,
                        title=Ast.Text(line=3, text="Given I have a garden in the database"),
                        table=Ast.Table(
                            line=4, fields=[["@name", "area", "raining"], ["Secret Garden", "45", "false"]]
                        ),
                    ),
                    Ast.Step(
                        line=6,
                        title=Ast.Text(line=6, text="And I have gardens in the database"),
                        table=Ast.Table(
                            line=7, fields=[["name", "area", "raining"], ["Octopus' Garden", "120", "true"]]
                        ),
                    ),
                ],
            ),
            scenarios=[
                Ast.Scenario(
                    title=Ast.Text(line=9, text="Plant a tree"),
                    line=9,
                    steps=[
                        Ast.Step(line=10, title=Ast.Text(line=10, text="Given the <name> of a garden")),
                        Ast.Step(line=11, title=Ast.Text(line=11, text="When I plant a tree")),
                        Ast.Step(line=12, title=Ast.Text(line=12, text="And wait for <num_days> days")),
                        Ast.Step(line=13, title=Ast.Text(line=13, text="Then I see it growing")),
                    ],
                )
            ],
        )
    )
Ejemplo n.º 30
0
def test_parse_tables_within_steps():
    "Lexer.run() Should be able to parse example tables from steps"

    # Given a parser loaded with steps that contain example tables
    '''Feature: Check models existence
		Background:
	   Given I have a garden in the database:
	      | @name  | area | raining |
	      | Secret Garden | 45   | false   |
	    And I have gardens in the database:
	      | name            | area | raining |
	      | Octopus' Garden | 120  | true    |
         Scenario: Plant a tree
           Given the <name> of a garden
           When I plant a tree
            And wait for <num_days> days
           Then I see it growing
    '''
    parser = Parser([(1, gherkin.TOKEN_LABEL, 'Feature'),
                     (1, gherkin.TOKEN_TEXT, 'Check models existence'),
                     (1, gherkin.TOKEN_NEWLINE, '\n'),
                     (2, gherkin.TOKEN_LABEL, 'Background'),
                     (2, gherkin.TOKEN_NEWLINE, '\n'),
                     (3, gherkin.TOKEN_LABEL,
                      'Given I have a garden in the database'),
                     (3, gherkin.TOKEN_NEWLINE, '\n'),
                     (4, gherkin.TOKEN_TABLE_COLUMN, '@name'),
                     (4, gherkin.TOKEN_TABLE_COLUMN, 'area'),
                     (4, gherkin.TOKEN_TABLE_COLUMN, 'raining'),
                     (4, gherkin.TOKEN_NEWLINE, '\n'),
                     (5, gherkin.TOKEN_TABLE_COLUMN, 'Secret Garden'),
                     (5, gherkin.TOKEN_TABLE_COLUMN, '45'),
                     (5, gherkin.TOKEN_TABLE_COLUMN, 'false'),
                     (5, gherkin.TOKEN_NEWLINE, '\n'),
                     (6, gherkin.TOKEN_LABEL,
                      'And I have gardens in the database'),
                     (6, gherkin.TOKEN_NEWLINE, '\n'),
                     (7, gherkin.TOKEN_TABLE_COLUMN, 'name'),
                     (7, gherkin.TOKEN_TABLE_COLUMN, 'area'),
                     (7, gherkin.TOKEN_TABLE_COLUMN, 'raining'),
                     (7, gherkin.TOKEN_NEWLINE, '\n'),
                     (8, gherkin.TOKEN_TABLE_COLUMN, "Octopus' Garden"),
                     (8, gherkin.TOKEN_TABLE_COLUMN, '120'),
                     (8, gherkin.TOKEN_TABLE_COLUMN, 'true'),
                     (8, gherkin.TOKEN_NEWLINE, '\n'),
                     (9, gherkin.TOKEN_LABEL, 'Scenario'),
                     (9, gherkin.TOKEN_TEXT, 'Plant a tree'),
                     (9, gherkin.TOKEN_NEWLINE, '\n'),
                     (10, gherkin.TOKEN_TEXT, 'Given the <name> of a garden'),
                     (10, gherkin.TOKEN_NEWLINE, '\n'),
                     (11, gherkin.TOKEN_TEXT, 'When I plant a tree'),
                     (11, gherkin.TOKEN_NEWLINE, '\n'),
                     (12, gherkin.TOKEN_TEXT, 'And wait for <num_days> days'),
                     (12, gherkin.TOKEN_NEWLINE, '\n'),
                     (13, gherkin.TOKEN_TEXT, 'Then I see it growing'),
                     (13, gherkin.TOKEN_NEWLINE, '\n'),
                     (14, gherkin.TOKEN_EOF, '')])

    feature = parser.parse_feature()

    feature.should.equal(
        Ast.Feature(
            line=1,
            title=Ast.Text(line=1, text='Check models existence'),
            background=Ast.Background(
                line=2,
                steps=[
                    Ast.Step(line=3,
                             title=Ast.Text(
                                 line=3,
                                 text='Given I have a garden in the database'),
                             table=Ast.Table(
                                 line=4,
                                 fields=[['@name', 'area', 'raining'],
                                         ['Secret Garden', '45', 'false']])),
                    Ast.Step(line=6,
                             title=Ast.Text(
                                 line=6,
                                 text='And I have gardens in the database'),
                             table=Ast.Table(
                                 line=7,
                                 fields=[['name', 'area', 'raining'],
                                         ['Octopus\' Garden', '120',
                                          'true']])),
                ]),
            scenarios=[
                Ast.Scenario(
                    title=Ast.Text(line=9, text='Plant a tree'),
                    line=9,
                    steps=[
                        Ast.Step(line=10,
                                 title=Ast.Text(
                                     line=10,
                                     text='Given the <name> of a garden')),
                        Ast.Step(line=11,
                                 title=Ast.Text(line=11,
                                                text='When I plant a tree')),
                        Ast.Step(line=12,
                                 title=Ast.Text(
                                     line=12,
                                     text='And wait for <num_days> days')),
                        Ast.Step(line=13,
                                 title=Ast.Text(line=13,
                                                text='Then I see it growing'))
                    ])
            ],
        ))