model.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 import model
from robot.conf import RobotSettings
from robot.errors import BreakLoop, ContinueLoop, ReturnFromKeyword, DataError
from robot.model import Keywords, BodyItem
from robot.output import LOGGER, Output, pyloggingconf
from robot.result import (Break as BreakResult, Continue as ContinueResult,
                          Return as ReturnResult)
from robot.utils import seq2str, setter
 
from .bodyrunner import ForRunner, IfRunner, KeywordRunner, TryRunner, WhileRunner
from .randomizer import Randomizer
from .statusreporter import StatusReporter
 
 
class Body(model.Body):
    __slots__ = []
 
 
@Body.register
 
class Keyword(model.Keyword):
    __slots__ = ['lineno']
 
    def __init__(self, name='', doc='', args=(), assign=(), tags=(), timeout=None,
                 type=BodyItem.KEYWORD, parent=None, lineno=None):
        super().__init__(name, doc, args, assign, tags, timeout, type, parent)
        self.linenolineno = lineno
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=None):
        return KeywordRunner(context, run).run(self)
 
 
@Body.register
class For(model.For):
    __slots__ = ['lineno', 'error']
    body_class = Body
 
    def __init__(self, variables, flavor, values, parent=None, lineno=None, error=None):
        super().__init__(variables, flavor, values, parent)
        self.linenolineno = lineno
        self.errorerror = error
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=False):
        return ForRunner(context, self.flavorflavor, run, templated).run(self)
 
 
@Body.register
class While(model.While):
    __slots__ = ['lineno', 'error']
    body_class = Body
 
    def __init__(self, condition=None, limit=None, parent=None, lineno=None, error=None):
        super().__init__(condition, limit, parent)
        self.linenolineno = lineno
        self.errorerror = error
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=False):
        return WhileRunner(context, run, templated).run(self)
 
 
class IfBranch(model.IfBranch):
    __slots__ = ['lineno']
    body_class = Body
 
    def __init__(self, type=BodyItem.IF, condition=None, parent=None, lineno=None):
        super().__init__(type, condition, parent)
        self.linenolineno = lineno
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
 
@Body.register
class If(model.If):
    __slots__ = ['lineno', 'error']
    branch_class = IfBranch
 
    def __init__(self, parent=None, lineno=None, error=None):
        super().__init__(parent)
        self.linenolineno = lineno
        self.errorerror = error
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=False):
        return IfRunner(context, run, templated).run(self)
 
 
class TryBranch(model.TryBranch):
    __slots__ = ['lineno']
    body_class = Body
 
    def __init__(self, type=BodyItem.TRY, patterns=(), pattern_type=None,
                 variable=None, parent=None, lineno=None):
        super().__init__(type, patterns, pattern_type, variable, parent)
        self.linenolineno = lineno
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
 
@Body.register
class Try(model.Try):
    __slots__ = ['lineno', 'error']
    branch_class = TryBranch
 
    def __init__(self, parent=None, lineno=None, error=None):
        super().__init__(parent)
        self.linenolineno = lineno
        self.errorerror = error
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=False):
        return TryRunner(context, run, templated).run(self)
 
 
@Body.register
class Return(model.Return):
    __slots__ = ['lineno', 'error']
 
    def __init__(self, values=(), parent=None, lineno=None, error=None):
        super().__init__(values, parent)
        self.linenolineno = lineno
        self.errorerror = error
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=False):
        with StatusReporter(self, ReturnResult(self.valuesvalues), context, run):
            if run:
                if self.errorerror:
                    raise DataError(self.errorerror, syntax=True)
                if not context.dry_run:
                    raise ReturnFromKeyword(self.valuesvalues)
 
 
@Body.register
class Continue(model.Continue):
    __slots__ = ['lineno', 'error']
 
    def __init__(self, parent=None, lineno=None, error=None):
        super().__init__(parent)
        self.linenolineno = lineno
        self.errorerror = error
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=False):
        with StatusReporter(self, ContinueResult(), context, run):
            if run:
                if self.errorerror:
                    raise DataError(self.errorerror, syntax=True)
                if not context.dry_run:
                    raise ContinueLoop()
 
 
@Body.register
class Break(model.Break):
    __slots__ = ['lineno', 'error']
 
    def __init__(self, parent=None, lineno=None, error=None):
        super().__init__(parent)
        self.linenolineno = lineno
        self.errorerror = error
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
    def run(self, context, run=True, templated=False):
        with StatusReporter(self, BreakResult(), context, run):
            if run:
                if self.errorerror:
                    raise DataError(self.errorerror, syntax=True)
                if not context.dry_run:
                    raise BreakLoop()
 
 
 
class TestCase(model.TestCase):
    __slots__ = ['template']
    body_class = Body        #: Internal usage only.
    fixture_class = Keyword  #: Internal usage only.
 
    def __init__(self, name='', doc='', tags=None, timeout=None, template=None,
                 lineno=None):
        super().__init__(name, doc, tags, timeout, lineno)
        #: Name of the keyword that has been used as a template when building the test.
        # ``None`` if template is not used.
        self.templatetemplate = template
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
 
 
class TestSuite(model.TestSuite):
    __slots__ = ['resource']
    test_class = TestCase    #: Internal usage only.
    fixture_class = Keyword  #: Internal usage only.
 
    def __init__(self,  name='', doc='', metadata=None, source=None, rpa=None):
        super().__init__(name, doc, metadata, source, rpa)
        #: :class:`ResourceFile` instance containing imports, variables and
        #: keywords the suite owns. When data is parsed from the file system,
        #: this data comes from the same test case file that creates the suite.
        self.resourceresource = ResourceFile(source=source)
 
    @classmethod
    
    def from_file_system(cls, *paths, **config):
        from .builder import TestSuiteBuilder
        return TestSuiteBuilder(**config).build(*paths)
 
    @classmethod
    
    def from_model(cls, model, name=None):
        from .builder import RobotParser
        return RobotParser().build_suite(model, name)
 
    
    def configure(self, randomize_suites=False, randomize_tests=False,
                  randomize_seed=None, **options):
        model.TestSuite.configure(self, **options)
        self.randomizerandomize(randomize_suites, randomize_tests, randomize_seed)
 
    
    def randomize(self, suites=True, tests=True, seed=None):
        self.visitvisit(Randomizer(suites, tests, seed))
 
    
    def run(self, settings=None, **options):
        from .namespace import IMPORTER
        from .signalhandler import STOP_SIGNAL_MONITOR
        from .suiterunner import SuiteRunner
 
        with LOGGER:
            if not settings:
                settings = RobotSettings(options)
                LOGGER.register_console_logger(**settings.console_output_config)
            with pyloggingconf.robot_handler_enabled(settings.log_level):
                with STOP_SIGNAL_MONITOR:
                    IMPORTER.reset()
                    output = Output(settings)
                    runner = SuiteRunner(output, settings)
                    self.visitvisit(runner)
                output.close(runner.result)
        return runner.result
 
 
class Variable:
 
    def __init__(self, name, value, source=None, lineno=None, error=None):
        self.namename = name
        self.valuevalue = value
        self.sourcesource = source
        self.linenolineno = lineno
        self.errorerror = error
 
    def report_invalid_syntax(self, message, level='ERROR'):
        source = self.sourcesource or '<unknown>'
        line = f' on line {self.lineno}' if self.linenolineno else ''
        LOGGER.write(f"Error in file '{source}'{line}: "
                     f"Setting variable '{self.name}' failed: {message}", level)
 
 
class ResourceFile:
 
    def __init__(self, doc='', source=None):
        self.docdoc = doc
        self.sourcesource = source
        self.importsimportsimports = []
        self.keywordskeywordskeywords = []
        self.variablesvariablesvariables = []
 
    @setter
    def imports(self, imports):
        return Imports(self.sourcesource, imports)
 
    @setter
    def keywords(self, keywords):
        return model.ItemList(UserKeyword, {'parent': self}, items=keywords)
 
    @setter
    def variables(self, variables):
        return model.ItemList(Variable, {'source': self.sourcesource}, items=variables)
 
 
class UserKeyword:
 
    def __init__(self, name, args=(), doc='', tags=(), return_=None,
                 timeout=None, lineno=None, parent=None, error=None):
        self.namename = name
        self.argsargs = args
        self.docdoc = doc
        self.tagstagstags = tags
        self.return_return_ = return_ or ()
        self.timeouttimeout = timeout
        self.linenolineno = lineno
        self.parentparent = parent
        self.errorerror = error
        self.bodybodybody = None
        self._teardown_teardown = None
 
    @setter
    
    def body(self, body):
        return Body(self, body)
 
    @property
    
    keywords = property
    
    def keywords(self):
        kws = list(self.bodybodybody)
        if self.teardownteardownteardown:
            kws.append(self.teardownteardownteardown)
        return Keywords(self, kws)
 
    @keywords.setter
    
    def keywords(self, keywords):
        Keywords.raise_deprecation_error()
 
    @property
    teardown = property
    
    def teardown(self):
        if self._teardown_teardown is None:
            self._teardown_teardown = Keyword(None, parent=self, type=Keyword.TEARDOWN)
        return self._teardown_teardown
 
    @setter
    def tags(self, tags):
        return model.Tags(tags)
 
    @property
    source = property
    
    def source(self):
        return self.parentparent.source if self.parentparent is not None else None
 
 
class Import:
    ALLOWED_TYPES = ('Library', 'Resource', 'Variables')
 
    def __init__(self, type, name, args=(), alias=None, source=None, lineno=None):
        if type not in self.ALLOWED_TYPESALLOWED_TYPES:
            raise ValueError(f"Invalid import type '{type}'. Should be one of "
                             f"{seq2str(self.ALLOWED_TYPES, lastsep=' or ')}.")
        self.typetype = type
        self.namename = name
        self.argsargs = args
        self.aliasalias = alias
        self.sourcesource = source
        self.linenolineno = lineno
 
    @property
    directory = property
    
    def directory(self):
        if not self.sourcesource:
            return None
        if os.path.isdir(self.sourcesource):
            return self.sourcesource
        return os.path.dirname(self.sourcesource)
 
    def report_invalid_syntax(self, message, level='ERROR'):
        source = self.sourcesource or '<unknown>'
        line = f' on line {self.lineno}' if self.linenolineno else ''
        LOGGER.write(f"Error in file '{source}'{line}: {message}", level)
 
 
class Imports(model.ItemList):
 
    def __init__(self, source, imports=None):
        super().__init__(Import, {'source': source}, items=imports)
 
    def library(self, name, args=(), alias=None, lineno=None):
        self.createcreate('Library', name, args, alias, lineno)
 
    def resource(self, path, lineno=None):
        self.createcreate('Resource', path, lineno)
 
    def variables(self, path, args=(), lineno=None):
        self.createcreate('Variables', path, args, lineno)