Source code for robot.running.userkeyword

#  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.utils import getshortdoc, is_string, unic

from .builder import ResourceFileBuilder
from .arguments import EmbeddedArguments, UserKeywordArgumentParser
from .handlerstore import HandlerStore
from .userkeywordrunner import UserKeywordRunner, EmbeddedArgumentsRunner
from .usererrorhandler import UserErrorHandler


[docs]class UserLibrary(object): TEST_CASE_FILE_TYPE = HandlerStore.TEST_CASE_FILE_TYPE RESOURCE_FILE_TYPE = HandlerStore.RESOURCE_FILE_TYPE def __init__(self, source, source_type=RESOURCE_FILE_TYPE): if is_string(source): resource = ResourceFileBuilder().build(source) else: resource = source source = resource.source basename = os.path.basename(source) if source else None self.name = os.path.splitext(basename)[0] \ if source_type == self.RESOURCE_FILE_TYPE else None self.doc = resource.doc self.handlers = HandlerStore(basename, source_type) self.source = source self.source_type = source_type for kw in resource.keywords: try: handler = self._create_handler(kw) except DataError as error: handler = UserErrorHandler(error, kw.name, self.name) self._log_creating_failed(handler, error) embedded = isinstance(handler, EmbeddedArgumentsHandler) try: self.handlers.add(handler, embedded) except DataError as error: self._log_creating_failed(handler, error) def _create_handler(self, kw): embedded = EmbeddedArguments(kw.name) if not embedded: return UserKeywordHandler(kw, self.name) if kw.args: raise DataError('Keyword cannot have both normal and embedded ' 'arguments.') return EmbeddedArgumentsHandler(kw, self.name, embedded) def _log_creating_failed(self, handler, error): LOGGER.error("Error in %s '%s': Creating keyword '%s' failed: %s" % (self.source_type.lower(), self.source, handler.name, error.message))
# TODO: Should be merged with running.model.UserKeyword
[docs]class UserKeywordHandler(object): def __init__(self, keyword, libname): self.name = keyword.name self.libname = libname self.doc = unic(keyword.doc) self.tags = keyword.tags self.arguments = UserKeywordArgumentParser().parse(tuple(keyword.args), self.longname) self._kw = keyword self.timeout = keyword.timeout self.keywords = keyword.keywords.normal self.return_value = tuple(keyword.return_) self.teardown = keyword.keywords.teardown @property def longname(self): return '%s.%s' % (self.libname, self.name) if self.libname else self.name @property def shortdoc(self): return getshortdoc(self.doc)
[docs] def create_runner(self, name): return UserKeywordRunner(self)
[docs]class EmbeddedArgumentsHandler(UserKeywordHandler): def __init__(self, keyword, libname, embedded): UserKeywordHandler.__init__(self, keyword, libname) self.keyword = keyword self.embedded_name = embedded.name self.embedded_args = embedded.args
[docs] def matches(self, name): return self.embedded_name.match(name) is not None
[docs] def create_runner(self, name): return EmbeddedArgumentsRunner(self, name)