Beispiel #1
0
    def test_model_error_with_error_and_fatal_error(self):
        model = get_resource_model('''\
*** Invalid ***
*** Settings ***
Invalid
Documentation
*** Test Cases ***
''',
                                   data_only=True)
        inv_header = (
            "Unrecognized section header '*** Invalid ***'. Valid sections: "
            "'Settings', 'Variables', 'Keywords' and 'Comments'.")
        inv_setting = "Non-existing setting 'Invalid'."
        inv_testcases = "Resource file with 'Test Cases' section is invalid."
        expected = File([
            CommentSection(body=[
                Error([Token('ERROR', '*** Invalid ***', 1, 0, inv_header)])
            ]),
            SettingSection(
                header=SectionHeader(
                    [Token('SETTING HEADER', '*** Settings ***', 2, 0)]),
                body=[
                    Error([Token('ERROR', 'Invalid', 3, 0, inv_setting)]),
                    Documentation(
                        [Token('DOCUMENTATION', 'Documentation', 4, 0)]),
                    Error([
                        Token('FATAL ERROR', '*** Test Cases ***', 5, 0,
                              inv_testcases)
                    ])
                ])
        ])
        assert_model(model, expected)
    def test_model(self):
        model = get_model('''\
*** Invalid ***
*** Settings ***
Invalid
Documentation
''', data_only=True)
        inv_header = (
            "Unrecognized section header '*** Invalid ***'. Valid sections: "
            "'Settings', 'Variables', 'Test Cases', 'Tasks', 'Keywords' and 'Comments'."
        )
        inv_setting = "Non-existing setting 'Invalid'."
        expected = File([
            CommentSection(
                body=[
                    Error([Token('ERROR', '*** Invalid ***', 1, 0, inv_header)])
                ]
            ),
            SettingSection(
                header=SectionHeader([
                    Token('SETTING HEADER', '*** Settings ***', 2, 0)
                ]),
                body=[
                    Error([Token('ERROR', 'Invalid', 3, 0, inv_setting)]),
                    Documentation([Token('DOCUMENTATION', 'Documentation', 4, 0)])
                ]
            )
        ])
        assert_model(model, expected)
Beispiel #3
0
    def test_ast_NodeTransformer(self):
        class Transformer(ast.NodeTransformer):
            def visit_Tags(self, node):
                return None

            def visit_TestCaseSection(self, node):
                self.generic_visit(node)
                node.body.append(
                    TestCase(
                        TestCaseName([
                            Token('TESTCASE_NAME', 'Added'),
                            Token('EOL', '\n')
                        ])))
                return node

            def visit_TestCase(self, node):
                self.generic_visit(node)
                return node if node.name != 'REMOVE' else None

            def visit_TestCaseName(self, node):
                name_token = node.get_token(Token.TESTCASE_NAME)
                name_token.value = name_token.value.upper()
                return node

            def visit_Block(self, node):
                raise RuntimeError('Should not be executed.')

            def visit_Statement(self, node):
                raise RuntimeError('Should not be executed.')

        model = get_model('''\
*** Test Cases ***
Example
    [Tags]    to be removed
Remove
''')
        Transformer().visit(model)
        expected = File(sections=[
            TestCaseSection(header=TestCaseSectionHeader([
                Token('TESTCASE_HEADER', '*** Test Cases ***', 1, 0),
                Token('EOL', '\n', 1, 18)
            ]),
                            body=[
                                TestCase(
                                    TestCaseName([
                                        Token('TESTCASE_NAME', 'EXAMPLE', 2,
                                              0),
                                        Token('EOL', '\n', 2, 7)
                                    ])),
                                TestCase(
                                    TestCaseName([
                                        Token('TESTCASE_NAME', 'Added'),
                                        Token('EOL', '\n')
                                    ]))
                            ])
        ])
        assert_model(model, expected)
Beispiel #4
0
    def test_model_error_with_fatal_error(self):
        model = get_resource_model('''\
*** Test Cases ***
''', data_only=True)
        inv_testcases = "Resource file with 'Test Cases' section is invalid."
        expected = File([
            CommentSection(
                body=[
                    Error([Token('FATAL ERROR', '*** Test Cases ***', 1, 0, inv_testcases)])
                ]
            )
        ])
        assert_model(model, expected)
    def test_ModelTransformer(self):

        class Transformer(ModelTransformer):

            def visit_SectionHeader(self, node):
                return node

            def visit_TestCaseName(self, node):
                return node

            def visit_Statement(self, node):
                return None

            def visit_Block(self, node):
                self.generic_visit(node)
                if hasattr(node, 'header'):
                    for token in node.header.data_tokens:
                        token.value = token.value.upper()
                return node

        model = get_model('''\
*** Test Cases ***
Example
    [Tags]    to be removed
    To be removed
''')
        Transformer().visit(model)
        expected = File(sections=[
            TestCaseSection(
                header=SectionHeader([
                    Token('TESTCASE HEADER', '*** TEST CASES ***', 1, 0),
                    Token('EOL', '\n', 1, 18)
                ]),
                body=[
                    TestCase(TestCaseName([
                        Token('TESTCASE NAME', 'EXAMPLE', 2, 0),
                        Token('EOL', '\n', 2, 7)
                    ])),
                ]
            )
        ])
        assert_model(model, expected)
Beispiel #6
0
EXPECTED = File(sections=[
    CommentSection(body=[EmptyLine([Token('EOL', '\n', 1, 0)])]),
    TestCaseSection(header=TestCaseSectionHeader([
        Token('TESTCASE_HEADER', '*** Test Cases ***', 2, 0),
        Token('EOL', '\n', 2, 18)
    ]),
                    body=[
                        EmptyLine([Token('EOL', '\n', 3, 0)]),
                        TestCase(header=TestCaseName([
                            Token('TESTCASE_NAME', 'Example', 4, 0),
                            Token('EOL', '\n', 4, 7)
                        ]),
                                 body=[
                                     Comment([
                                         Token('SEPARATOR', '  ', 5, 0),
                                         Token('COMMENT', '# Comment', 5, 2),
                                         Token('EOL', '\n', 5, 11),
                                     ]),
                                     KeywordCall([
                                         Token('SEPARATOR', '    ', 6, 0),
                                         Token('KEYWORD', 'Keyword', 6, 4),
                                         Token('SEPARATOR', '    ', 6, 11),
                                         Token('ARGUMENT', 'arg', 6, 15),
                                         Token('EOL', '\n', 6, 18),
                                         Token('SEPARATOR', '    ', 7, 0),
                                         Token('CONTINUATION', '...', 7, 4),
                                         Token('SEPARATOR', '\t', 7, 7),
                                         Token('ARGUMENT', 'argh', 7, 8),
                                         Token('EOL', '\n', 7, 12)
                                     ]),
                                     EmptyLine([Token('EOL', '\n', 8, 0)]),
                                     EmptyLine([Token('EOL', '\t\t\n', 9, 0)])
                                 ])
                    ]),
    KeywordSection(header=KeywordSectionHeader([
        Token('KEYWORD_HEADER', '*** Keywords ***', 10, 0),
        Token('EOL', '\n', 10, 16)
    ]),
                   body=[
                       Comment([
                           Token('COMMENT', '# Comment', 11, 0),
                           Token('SEPARATOR', '    ', 11, 9),
                           Token('COMMENT', 'continues', 11, 13),
                           Token('EOL', '\n', 11, 22),
                       ]),
                       Keyword(
                           header=KeywordName(
                               [
                                   Token('KEYWORD_NAME', 'Keyword', 12, 0),
                                   Token('EOL', '\n', 12, 7)
                               ]),
                           body=[
                               Arguments([
                                   Token('SEPARATOR', '    ', 13, 0),
                                   Token('ARGUMENTS', '[Arguments]', 13, 4),
                                   Token('SEPARATOR', '    ', 13, 15),
                                   Token('ARGUMENT', '${arg1}', 13, 19),
                                   Token('SEPARATOR', '    ', 13, 26),
                                   Token('ARGUMENT', '${arg2}', 13, 30),
                                   Token('EOL', '\n', 13, 37)
                               ]),
                               KeywordCall([
                                   Token('SEPARATOR', '    ', 14, 0),
                                   Token('KEYWORD', 'Log', 14, 4),
                                   Token('SEPARATOR', '    ', 14, 7),
                                   Token('ARGUMENT', 'Got ${arg1} and ${arg}!',
                                         14, 11),
                                   Token('EOL', '\n', 14, 34)
                               ])
                           ])
                   ])
])
Beispiel #7
0
EXPECTED = File(sections=[
    CommentSection(body=[EmptyLine([Token('EOL', '\n', 1, 0)])]),
    TestCaseSection(header=TestCaseSectionHeader([
        Token('TESTCASE_HEADER', '*** Test Cases ***', 2, 0),
        Token('EOL', '\n', 2, 18)
    ]),
                    body=[
                        TestCase(header=Name([
                            Token('NAME', 'Example', 3, 0),
                            Token('EOL', '\n', 3, 7)
                        ]),
                                 body=[
                                     KeywordCall([
                                         Token('SEPARATOR', '    ', 4, 0),
                                         Token('KEYWORD', 'Keyword', 4, 4),
                                         Token('SEPARATOR', '    ', 4, 11),
                                         Token('ARGUMENT', 'arg', 4, 15),
                                         Token('EOL', '\n', 4, 18),
                                         Token('SEPARATOR', '    ', 5, 0),
                                         Token('CONTINUATION', '...', 5, 4),
                                         Token('SEPARATOR', '    ', 5, 7),
                                         Token('ARGUMENT', 'argh', 5, 11),
                                         Token('EOL', '\n', 5, 15)
                                     ]),
                                     EmptyLine([Token('EOL', '\n', 6, 0)])
                                 ])
                    ]),
    KeywordSection(header=KeywordSectionHeader([
        Token('KEYWORD_HEADER', '*** Keywords ***', 7, 0),
        Token('EOL', '\n', 7, 16)
    ]),
                   body=[
                       Keyword(header=Name([
                           Token('NAME', 'Keyword', 8, 0),
                           Token('EOL', '\n', 8, 7)
                       ]),
                               body=[
                                   Arguments([
                                       Token('SEPARATOR', '    ', 9, 0),
                                       Token('ARGUMENTS', '[Arguments]', 9, 4),
                                       Token('SEPARATOR', '    ', 9, 15),
                                       Token('ARGUMENT', '${arg1}', 9, 19),
                                       Token('SEPARATOR', '    ', 9, 26),
                                       Token('ARGUMENT', '${arg2}', 9, 30),
                                       Token('EOL', '\n', 9, 37)
                                   ]),
                                   KeywordCall([
                                       Token('SEPARATOR', '    ', 10, 0),
                                       Token('KEYWORD', 'Log', 10, 4),
                                       Token('SEPARATOR', '    ', 10, 7),
                                       Token('ARGUMENT',
                                             'Got ${arg1} and ${arg}!', 10,
                                             11),
                                       Token('EOL', '\n', 10, 34)
                                   ])
                               ])
                   ])
])