builders.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
import os
 
from robot.errors import DataError
from robot.output import LOGGER
from robot.parsing import SuiteStructureBuilder, SuiteStructureVisitor
 
from .parsers import RobotParser, NoInitFileDirectoryParser, RestParser
from .settings import Defaults
 
 
 
class TestSuiteBuilder:
 
    
    def __init__(self, included_suites=None, included_extensions=('robot',),
                 rpa=None, lang=None, allow_empty_suite=False,
                 process_curdir=True):
        self.rparpa = rpa
        self.langlang = lang
        self.included_suitesincluded_suites = included_suites
        self.included_extensionsincluded_extensions = included_extensions
        self.allow_empty_suiteallow_empty_suite = allow_empty_suite
        self.process_curdirprocess_curdir = process_curdir
 
    
    def build(self, *paths):
        structure = SuiteStructureBuilder(self.included_extensionsincluded_extensions,
                                          self.included_suitesincluded_suites).build(paths)
        parser = SuiteStructureParser(self.included_extensionsincluded_extensions,
                                      self.rparpa, self.langlang, self.process_curdirprocess_curdir)
        suite = parser.parse(structure)
        if not self.included_suitesincluded_suites and not self.allow_empty_suiteallow_empty_suite:
            self._validate_test_counts_validate_test_counts(suite, multisource=len(paths) > 1)
        suite.remove_empty_suites(preserve_direct_children=len(paths) > 1)
        return suite
 
    def _validate_test_counts(self, suite, multisource=False):
        def validate(suite):
            if not suite.has_tests:
                raise DataError(f"Suite '{suite.name}' contains no tests or tasks.")
        if not multisource:
            validate(suite)
        else:
            for s in suite.suites:
                validate(s)
 
 
class SuiteStructureParser(SuiteStructureVisitor):
 
    def __init__(self, included_extensions, rpa=None, lang=None, process_curdir=True):
        self.rparpa = rpa
        self._rpa_given_rpa_given = rpa is not None
        self.suitesuite = None
        self._stack_stack = []
        self.parsersparsers = self._get_parsers_get_parsers(included_extensions, lang, process_curdir)
 
    def _get_parsers(self, extensions, lang, process_curdir):
        robot_parser = RobotParser(lang, process_curdir)
        rest_parser = RestParser(lang, process_curdir)
        parsers = {
            None: NoInitFileDirectoryParser(),
            'robot': robot_parser,
            'rst': rest_parser,
            'rest': rest_parser
        }
        for ext in extensions:
            if ext not in parsers:
                parsers[ext] = robot_parser
        return parsers
 
    def _get_parser(self, extension):
        try:
            return self.parsersparsers[extension]
        except KeyError:
            return self.parsersparsers['robot']
 
    def parse(self, structure):
        structure.visit(self)
        self.suitesuite.rpa = self.rparpa
        return self.suitesuite
 
    def visit_file(self, structure):
        LOGGER.info(f"Parsing file '{structure.source}'.")
        suite, _ = self._build_suite_build_suite(structure)
        if self._stack_stack:
            self._stack_stack[-1][0].suites.append(suite)
        else:
            self.suitesuite = suite
 
    def start_directory(self, structure):
        if structure.source:
            LOGGER.info(f"Parsing directory '{structure.source}'.")
        suite, defaults = self._build_suite_build_suite(structure)
        if self.suitesuite is None:
            self.suitesuite = suite
        else:
            self._stack_stack[-1][0].suites.append(suite)
        self._stack_stack.append((suite, defaults))
 
    def end_directory(self, structure):
        suite, _ = self._stack_stack.pop()
        if suite.rpa is None and suite.suites:
            suite.rpa = suite.suites[0].rpa
 
    def _build_suite(self, structure):
        parent_defaults = self._stack_stack[-1][-1] if self._stack_stack else None
        source = structure.source
        defaults = Defaults(parent_defaults)
        parser = self._get_parser_get_parser(structure.extension)
        try:
            if structure.is_directory:
                suite = parser.parse_init_file(structure.init_file or source, defaults)
            else:
                suite = parser.parse_suite_file(source, defaults)
                if not suite.tests:
                    LOGGER.info(f"Data source '{source}' has no tests or tasks.")
            self._validate_execution_mode_validate_execution_mode(suite)
        except DataError as err:
            raise DataError(f"Parsing '{source}' failed: {err.message}")
        return suite, defaults
 
    def _validate_execution_mode(self, suite):
        if self._rpa_given_rpa_given:
            suite.rpa = self.rparpa
        elif suite.rpa is None:
            pass
        elif self.rparpa is None:
            self.rparpa = suite.rpa
        elif self.rparpa is not suite.rpa:
            this, that = ('tasks', 'tests') if suite.rpa else ('tests', 'tasks')
            raise DataError(f"Conflicting execution modes. File has {this} "
                            f"but files parsed earlier have {that}. Fix headers "
                            f"or use '--rpa' or '--norpa' options to set the "
                            f"execution mode explicitly.")
 
 
class ResourceFileBuilder:
 
    def __init__(self, lang=None, process_curdir=True):
        self.langlang = lang
        self.process_curdirprocess_curdir = process_curdir
 
    def build(self, source):
        LOGGER.info(f"Parsing resource file '{source}'.")
        resource = self._parse_parse(source)
        if resource.imports or resource.variables or resource.keywords:
            LOGGER.info(f"Imported resource file '{source}' ({len(resource.keywords)} "
                        f"keywords).")
        else:
            LOGGER.warn(f"Imported resource file '{source}' is empty.")
        return resource
 
    def _parse(self, source):
        if os.path.splitext(source)[1].lower() in ('.rst', '.rest'):
            return RestParser(self.langlang, self.process_curdirprocess_curdir).parse_resource_file(source)
        return RobotParser(self.langlang, self.process_curdirprocess_curdir).parse_resource_file(source)