def test_ignore_error(self):
v = Variables()
v['${X}'] = 'x'
v['@{Y}'] = [1, 2, 3]
for item in [
'${foo}', 'foo${bar}', '${foo}', '@{zap}', '${Y}[7]', '${inv',
'${{inv}', '${var}[inv', '${var}[key][inv'
]:
x_at_end = 'x' if (item.count('{') == item.count('}') and
item.count('[') == item.count(']')) else '${x}'
assert_equal(v.replace_string(item, ignore_errors=True), item)
assert_equal(
v.replace_string('${x}' + item + '${x}', ignore_errors=True),
'x' + item + x_at_end)
assert_equal(v.replace_scalar(item, ignore_errors=True), item)
assert_equal(
v.replace_scalar('${x}' + item + '${x}', ignore_errors=True),
'x' + item + x_at_end)
assert_equal(v.replace_list([item], ignore_errors=True), [item])
assert_equal(
v.replace_list(['${X}', item, '@{Y}'], ignore_errors=True),
['x', item, 1, 2, 3])
assert_equal(
v.replace_list(['${x}' + item + '${x}', '@{NON}'],
ignore_errors=True),
['x' + item + x_at_end, '@{NON}'])
def _load_config(self):
"""Load config.py as a variable file in a way that the individual
variables can be overriden on command line as if it was loaded
explicitly as a variables file.
"""
source_dir = os.path.dirname(os.path.abspath(__file__))
# Config file is meant to live in the output directory...
config_file = os.path.abspath('config.py')
if not os.path.exists(config_file):
# ...but look also into the sources to allow RED to do its job
config_file = os.path.join(source_dir, 'config.py')
if not os.path.exists(config_file):
configure = os.path.join(source_dir, 'configure')
configure = os.path.relpath(configure)
raise ConfigurationError("Configuration file not found. Forgot to run '{}'?"
.format(configure))
config = Variables()
config.set_from_file(config_file)
try:
global_variables = BuiltIn().get_variables()
for name in config.as_dict():
if name in global_variables:
config[name] = global_variables[name]
except RobotNotRunningError:
# Use the defaults when the IDE queries variables
pass
return DotDict(config.as_dict(decoration=False))
def test_ignore_error(self):
v = Variables()
v['${X}'] = 'x'
v['@{Y}'] = [1, 2, 3]
for item in ['${foo}', 'foo${bar}', '${foo}', '@{zap}', '@{Y}[7]']:
assert_equal(v.replace_string(item, ignore_errors=True), item)
assert_equal(
v.replace_string('${x}' + item + '${x}', ignore_errors=True),
'x' + item + 'x')
assert_equal(v.replace_scalar(item, ignore_errors=True), item)
assert_equal(
v.replace_scalar('${x}' + item + '${x}', ignore_errors=True),
'x' + item + 'x')
assert_equal(v.replace_list([item], ignore_errors=True), [item])
assert_equal(
v.replace_list(['${X}', item, '@{Y}'], ignore_errors=True),
['x', item, 1, 2, 3])
def _load_config(self):
"""Load config.py as a variable file in a way that the individual
variables can be overriden on command line as if it was loaded
explicitly as a variables file.
"""
config_dir = os.path.dirname(os.path.abspath(__file__))
config_file = os.path.join(config_dir, 'config.py')
config = Variables()
config.set_from_file(config_file)
try:
global_variables = BuiltIn().get_variables()
for name in config.as_dict():
if name in global_variables:
config[name] = global_variables[name]
except RobotNotRunningError:
# Use the defaults when the IDE queries variables
pass
return DotDict(config.as_dict(decoration=False))
def _create_ctx(self):
suite = TestSuite()
variables = Variables()
EXECUTION_CONTEXTS._contexts = []
EXECUTION_CONTEXTS.start_suite(
suite, Namespace(variables, suite, suite.resource), self._output())
def setUp(self):
self.varz = Variables()
def test_copy(self):
varz = Variables()
varz['${foo}'] = 'bar'
copy = varz.copy()
assert_equal(copy['${foo}'], 'bar')
def run_doc(library_name: str,
output_filename: str,
additional_path: str,
additional_pythonpath_entries: List[str],
variables: Dict[str, str],
strip_traceback=True) -> Tuple[Any, Optional[str], Optional[str]]:
from robot.variables import Variables
from robot.errors import DataError
from robot.running.testlibraries import TestLibrary
from robot.utils import get_error_message
from robot.libdocpkg.builder import JavaDocBuilder, RESOURCE_EXTENSIONS, SPEC_EXTENSIONS
from robot.libdocpkg.model import LibraryDoc
from robot.libdocpkg.robotbuilder import KeywordDocBuilder, LibraryDocBuilder, ResourceDocBuilder
from robot.libdocpkg.specbuilder import SpecDocBuilder
def get_robot_version():
try:
import robot
v = str(robot.get_version())
except BaseException:
v = "unknown"
return v
def get_robot_major_version():
robot_version = get_robot_version()
major_version = 3
try:
if "." in robot_version:
major_version = int(robot_version.split(".")[0])
except BaseException:
pass
return major_version
def _LibraryDocumentation(library_or_resource,
name=None,
version=None,
doc_format=None,
variables=None):
builder = _DocumentationBuilder(library_or_resource, variables)
try:
libdoc = builder.build(library_or_resource)
except DataError:
raise
except BaseException:
raise DataError("Building library '%s' failed: %s" %
(library_or_resource, get_error_message()))
if name:
libdoc.name = name
if version:
libdoc.version = version
if doc_format:
libdoc.doc_format = doc_format
return libdoc
def _DocumentationBuilder(library_or_resource, variables):
extension = os.path.splitext(library_or_resource)[1][1:].lower()
if extension in RESOURCE_EXTENSIONS:
return ResourceDocBuilder()
if extension in SPEC_EXTENSIONS:
return SpecDocBuilder()
if extension == 'java':
return JavaDocBuilder()
return _LibraryDocBuilder(variables)
class _LibraryDocBuilder(LibraryDocBuilder):
def __init__(self, variables) -> None:
super().__init__()
self.variables = variables
def build(self, library):
name, args = self._split_library_name_and_args(library)
lib = TestLibrary(name, args, variables=self.variables)
libdoc = LibraryDoc(name=lib.name,
doc=self._get_doc(lib),
version=lib.version,
scope=str(lib.scope),
doc_format=lib.doc_format,
source=lib.source,
lineno=lib.lineno)
libdoc.inits = self._get_initializers(lib)
libdoc.keywords = KeywordDocBuilder().build_keywords(lib)
return libdoc
warning = None
old_path = sys.path
libdoc = None
try:
if additional_pythonpath_entries:
for p in additional_pythonpath_entries:
if p:
sys.path.insert(0, p)
if additional_path:
sys.path.insert(0, additional_path)
vars = Variables()
for n, v in variables.items():
vars[n] = v
libdoc = _LibraryDocumentation(library_name, variables=vars)
docutils_installed = True
if libdoc.doc_format == "REST":
try:
import docutils
except:
docutils_installed = False
if docutils_installed:
libdoc.convert_docs_to_html()
else:
warning = "reST format requires 'docutils' module to be installed."
libdoc.save(output_filename,
"XML:HTML" if get_robot_major_version() < 4 else "LIBSPEC")
return (libdoc, None, warning)
except BaseException as e:
msg: str = get_error_message()
if strip_traceback:
msg = msg[:msg.find("Traceback")].strip()
return None, msg, warning
finally:
sys.path = old_path
