# -*- coding: utf-8 -*- from __future__ import print_function import argparse import logging import os import re import sys import shlex import six from importlib import import_module from six.moves import configparser from behave.model import ScenarioOutline from behave.model_core import FileLocation from behave.reporter.junit import JUnitReporter from behave.reporter.summary import SummaryReporter from behave.tag_expression import make_tag_expression from behave.formatter.base import StreamOpener from behave.formatter import _registry as _format_registry from behave.userdata import UserData, parse_user_define from behave._types import Unknown from behave.textutil import select_best_encoding, to_texts # -- PYTHON 2/3 COMPATIBILITY: # SINCE Python 3.2: ConfigParser = SafeConfigParser ConfigParser = configparser.ConfigParser if six.PY2: ConfigParser = configparser.SafeConfigParser # ----------------------------------------------------------------------------- # CONFIGURATION DATA TYPES: # ----------------------------------------------------------------------------- class LogLevel(object): names = [ "NOTSET", "CRITICAL", "FATAL", "ERROR", "WARNING", "WARN", "INFO", "DEBUG", ] @staticmethod def parse(levelname, unknown_level=None): """ Convert levelname into a numeric log level. :param levelname: Logging levelname (as string) :param unknown_level: Used if levelname is unknown (optional). :return: Numeric log-level or unknown_level, if levelname is unknown. """ return getattr(logging, levelname.upper(), unknown_level) @classmethod def parse_type(cls, levelname): level = cls.parse(levelname, Unknown) if level is Unknown: message = "%s is unknown, use: %s" % \ (levelname, ", ".join(cls.names[1:])) raise argparse.ArgumentTypeError(message) return level @staticmethod def to_string(level): return logging.getLevelName(level) # ----------------------------------------------------------------------------- # CONFIGURATION SCHEMA: # ----------------------------------------------------------------------------- def valid_python_module(path): try: module_path, class_name = path.rsplit('.', 1) module = import_module(module_path) return getattr(module, class_name) except (ValueError, AttributeError, ImportError): raise argparse.ArgumentTypeError("No module named '%s' was found." % path) options = [ (("-c", "--no-color"), dict(action="store_false", dest="color", help="Disable the use of ANSI color escapes.")), (("--color",), dict(dest="color", choices=["never", "always", "auto"], default=os.getenv('BEHAVE_COLOR'), const="auto", nargs="?", help="""Use ANSI color escapes. Defaults to %(const)r. This switch is used to override a configuration file setting.""")), (("-d", "--dry-run"), dict(action="store_true", help="Invokes formatters without executing the steps.")), (("-D", "--define"), dict(dest="userdata_defines", type=parse_user_define, action="append", metavar="NAME=VALUE", help="""Define user-specific data for the config.userdata dictionary. Example: -D foo=bar to store it in config.userdata["foo"].""")), (("-e", "--exclude"), dict(metavar="PATTERN", dest="exclude_re", help="""Don't run feature files matching regular expression PATTERN.""")), (("-i", "--include"), dict(metavar="PATTERN", dest="include_re", help="Only run feature files matching regular expression PATTERN.")), (("--no-junit",), dict(action="store_false", dest="junit", help="Don't output JUnit-compatible reports.")), (("--junit",), dict(action="store_true", help="""Output JUnit-compatible reports. When junit is enabled, all stdout and stderr will be redirected and dumped to the junit report, regardless of the "--capture" and "--no-capture" options. """)), (("--junit-directory",), dict(metavar="PATH", dest="junit_directory", default="reports", help="""Directory in which to store JUnit reports.""")), (("--runner-class",), dict(action="store", default="behave.runner.Runner", type=valid_python_module, help="Tells Behave to use a specific runner. (default: %(default)s)")), ((), # -- CONFIGFILE only dict(dest="default_format", help="Specify default formatter (default: pretty).")), (("-f", "--format"), dict(action="append", help="""Specify a formatter. If none is specified the default formatter is used. Pass "--format help" to get a list of available formatters.""")), (("--steps-catalog",), dict(action="store_true", dest="steps_catalog", help="""Show a catalog of all available step definitions. SAME AS: --format=steps.catalog --dry-run --no-summary -q""")), ((), # -- CONFIGFILE only dict(dest="scenario_outline_annotation_schema", help="""Specify name annotation schema for scenario outline (default="{name} -- @{row.id} {examples.name}").""")), (("-k", "--no-skipped"), dict(action="store_false", dest="show_skipped", help="Don't print skipped steps (due to tags).")), (("--show-skipped",), dict(action="store_true", help="""Print skipped steps. This is the default behaviour. This switch is used to override a configuration file setting.""")), (("--no-snippets",), dict(action="store_false", dest="show_snippets", help="Don't print snippets for unimplemented steps.")), (("--snippets",), dict(action="store_true", dest="show_snippets", help="""Print snippets for unimplemented steps. This is the default behaviour. This switch is used to override a configuration file setting.""")), (("-m", "--no-multiline"), dict(action="store_false", dest="show_multiline", help="""Don't print multiline strings and tables under steps.""")), (("--multiline", ), dict(action="store_true", dest="show_multiline", help="""Print multiline strings and tables under steps. This is the default behaviour. This switch is used to override a configuration file setting.""")), (("-n", "--name"), dict(action="append", metavar="NAME_PATTERN", help="""Select feature elements (scenarios, ...) to run which match part of the given name (regex pattern). If this option is given more than once, it will match against all the given names.""")), (("--no-capture",), dict(action="store_false", dest="stdout_capture", help="""Don't capture stdout (any stdout output will be printed immediately.)""")), (("--capture",), dict(action="store_true", dest="stdout_capture", help="""Capture stdout (any stdout output will be printed if there is a failure.) This is the default behaviour. This switch is used to override a configuration file setting.""")), (("--no-capture-stderr",), dict(action="store_false", dest="stderr_capture", help="""Don't capture stderr (any stderr output will be printed immediately.)""")), (("--capture-stderr",), dict(action="store_true", dest="stderr_capture", help="""Capture stderr (any stderr output will be printed if there is a failure.) This is the default behaviour. This switch is used to override a configuration file setting.""")), (("--no-logcapture",), dict(action="store_false", dest="log_capture", help="""Don't capture logging. Logging configuration will be left intact.""")), (("--logcapture",), dict(action="store_true", dest="log_capture", help="""Capture logging. All logging during a step will be captured and displayed in the event of a failure. This is the default behaviour. This switch is used to override a configuration file setting.""")), (("--logging-level",), dict(type=LogLevel.parse_type, help="""Specify a level to capture logging at. The default is INFO - capturing everything.""")), (("--logging-format",), dict(help="""Specify custom format to print statements. Uses the same format as used by standard logging handlers. The default is "%%(levelname)s:%%(name)s:%%(message)s".""")), (("--logging-datefmt",), dict(help="""Specify custom date/time format to print statements. Uses the same format as used by standard logging handlers.""")), (("--logging-filter",), dict(help="""Specify which statements to filter in/out. By default, everything is captured. If the output is too verbose, use this option to filter out needless output. Example: --logging-filter=foo will capture statements issued ONLY to foo or foo.what.ever.sub but not foobar or other logger. Specify multiple loggers with comma: filter=foo,bar,baz. If any logger name is prefixed with a minus, eg filter=-foo, it will be excluded rather than included.""", config_help="""Specify which statements to filter in/out. By default, everything is captured. If the output is too verbose, use this option to filter out needless output. Example: ``logging_filter = foo`` will capture statements issued ONLY to "foo" or "foo.what.ever.sub" but not "foobar" or other logger. Specify multiple loggers with comma: ``logging_filter = foo,bar,baz``. If any logger name is prefixed with a minus, eg ``logging_filter = -foo``, it will be excluded rather than included.""")), (("--logging-clear-handlers",), dict(action="store_true", help="Clear all other logging handlers.")), (("--no-summary",), dict(action="store_false", dest="summary", help="""Don't display the summary at the end of the run.""")), (("--summary",), dict(action="store_true", dest="summary", help="""Display the summary at the end of the run.""")), (("-o", "--outfile"), dict(action="append", dest="outfiles", metavar="FILE", help="Write to specified file instead of stdout.")), ((), # -- CONFIGFILE only dict(action="append", dest="paths", help="Specify default feature paths, used when none are provided.")), (("-q", "--quiet"), dict(action="store_true", help="Alias for --no-snippets --no-source.")), (("-s", "--no-source"), dict(action="store_false", dest="show_source", help="""Don't print the file and line of the step definition with the steps.""")), (("--show-source",), dict(action="store_true", dest="show_source", help="""Print the file and line of the step definition with the steps. This is the default behaviour. This switch is used to override a configuration file setting.""")), (("--stage",), dict(help="""Defines the current test stage. The test stage name is used as name prefix for the environment file and the steps directory (instead of default path names). """)), (("--stop",), dict(action="store_true", help="Stop running tests at the first failure.")), # -- DISABLE-UNUSED-OPTION: Not used anywhere. # (("-S", "--strict"), # dict(action="store_true", # help="Fail if there are any undefined or pending steps.")), ((), # -- CONFIGFILE only dict(dest="default_tags", metavar="TAG_EXPRESSION", action="append", help="""Define default tags when non are provided. See --tags for more information.""")), (("-t", "--tags"), dict(action="append", metavar="TAG_EXPRESSION", help="""Only execute features or scenarios with tags matching TAG_EXPRESSION. Pass "--tags-help" for more information.""", config_help="""Only execute certain features or scenarios based on the tag expression given. See below for how to code tag expressions in configuration files.""")), (("-T", "--no-timings"), dict(action="store_false", dest="show_timings", help="""Don't print the time taken for each step.""")), (("--show-timings",), dict(action="store_true", dest="show_timings", help="""Print the time taken, in seconds, of each step after the step has completed. This is the default behaviour. This switch is used to override a configuration file setting.""")), (("-v", "--verbose"), dict(action="store_true", help="Show the files and features loaded.")), (("-w", "--wip"), dict(action="store_true", help="""Only run scenarios tagged with "wip". Additionally: use the "plain" formatter, do not capture stdout or logging output and stop at the first failure.""")), (("-x", "--expand"), dict(action="store_true", help="Expand scenario outline tables in output.")), (("--lang",), dict(metavar="LANG", help="Use keywords for a language other than English.")), (("--lang-list",), dict(action="store_true", help="List the languages available for --lang.")), (("--lang-help",), dict(metavar="LANG", help="List the translations accepted for one language.")), (("--tags-help",), dict(action="store_true", help="Show help for tag expressions.")), (("--version",), dict(action="store_true", help="Show version.")), ] # -- OPTIONS: With raw value access semantics in configuration file. raw_value_options = frozenset([ "logging_format", "logging_datefmt", # -- MAYBE: "scenario_outline_annotation_schema", ]) def read_configuration(path): # pylint: disable=too-many-locals, too-many-branches config = ConfigParser() config.optionxform = str # -- SUPPORT: case-sensitive keys config.read(path) config_dir = os.path.dirname(path) result = {} for fixed, keywords in options: if "dest" in keywords: dest = keywords["dest"] else: for opt in fixed: if opt.startswith("--"): dest = opt[2:].replace("-", "_") else: assert len(opt) == 2 dest = opt[1:] if dest in "tags_help lang_list lang_help version".split(): continue if not config.has_option("behave", dest): continue action = keywords.get("action", "store") if action == "store": use_raw_value = dest in raw_value_options result[dest] = config.get("behave", dest, raw=use_raw_value) elif action in ("store_true", "store_false"): result[dest] = config.getboolean("behave", dest) elif action == "append": if dest == "userdata_defines": continue # -- SKIP-CONFIGFILE: Command-line only option. result[dest] = \ [s.strip() for s in config.get("behave", dest).splitlines()] else: raise ValueError('action "%s" not implemented' % action) # -- STEP: format/outfiles coupling if "format" in result: # -- OPTIONS: format/outfiles are coupled in configuration file. formatters = result["format"] formatter_size = len(formatters) outfiles = result.get("outfiles", []) outfiles_size = len(outfiles) if outfiles_size < formatter_size: for formatter_name in formatters[outfiles_size:]: outfile = "%s.output" % formatter_name outfiles.append(outfile) result["outfiles"] = outfiles elif len(outfiles) > formatter_size: print("CONFIG-ERROR: Too many outfiles (%d) provided." % outfiles_size) result["outfiles"] = outfiles[:formatter_size] for paths_name in ("paths", "outfiles"): if paths_name in result: # -- Evaluate relative paths relative to location. # NOTE: Absolute paths are preserved by os.path.join(). paths = result[paths_name] result[paths_name] = \ [os.path.normpath(os.path.join(config_dir, p)) for p in paths] # -- STEP: Special additional configuration sections. # SCHEMA: config_section: data_name special_config_section_map = { "behave.formatters": "more_formatters", "behave.userdata": "userdata", } for section_name, data_name in special_config_section_map.items(): result[data_name] = {} if config.has_section(section_name): result[data_name].update(config.items(section_name)) return result def config_filenames(): paths = ["./", os.path.expanduser("~")] if sys.platform in ("cygwin", "win32") and "APPDATA" in os.environ: paths.append(os.path.join(os.environ["APPDATA"])) for path in reversed(paths): for filename in reversed( ("behave.ini", ".behaverc", "setup.cfg", "tox.ini")): filename = os.path.join(path, filename) if os.path.isfile(filename): yield filename def load_configuration(defaults, verbose=False): for filename in config_filenames(): if verbose: print('Loading config defaults from "%s"' % filename) defaults.update(read_configuration(filename)) if verbose: print("Using defaults:") for k, v in six.iteritems(defaults): print("%15s %s" % (k, v)) def setup_parser(): # construct the parser # usage = "%(prog)s [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]+" usage = "%(prog)s [options] [ [DIR|FILE|FILE:LINE] ]+" description = """\ Run a number of feature tests with behave.""" more = """ EXAMPLES: behave features/ behave features/one.feature features/two.feature behave features/one.feature:10 behave @features.txt """ parser = argparse.ArgumentParser(usage=usage, description=description) for fixed, keywords in options: if not fixed: continue # -- CONFIGFILE only. if "config_help" in keywords: keywords = dict(keywords) del keywords["config_help"] parser.add_argument(*fixed, **keywords) parser.add_argument("paths", nargs="*", help="Feature directory, file or file location (FILE:LINE).") return parser class Configuration(object): """Configuration object for behave and behave runners.""" # pylint: disable=too-many-instance-attributes defaults = dict( color='never' if sys.platform == "win32" else os.getenv('BEHAVE_COLOR', 'auto'), show_snippets=True, show_skipped=True, dry_run=False, show_source=True, show_timings=True, stdout_capture=True, stderr_capture=True, log_capture=True, logging_format="%(levelname)s:%(name)s:%(message)s", logging_level=logging.INFO, steps_catalog=False, summary=True, junit=False, stage=None, userdata={}, # -- SPECIAL: default_format="pretty", # -- Used when no formatters are configured. default_tags="", # -- Used when no tags are defined. scenario_outline_annotation_schema=u"{name} -- @{row.id} {examples.name}" ) cmdline_only_options = set("userdata_defines") def __init__(self, command_args=None, load_config=True, verbose=None, **kwargs): """ Constructs a behave configuration object. * loads the configuration defaults (if needed). * process the command-line args * store the configuration results :param command_args: Provide command args (as sys.argv). If command_args is None, sys.argv[1:] is used. :type command_args: list, str :param load_config: Indicate if configfile should be loaded (=true) :param verbose: Indicate if diagnostic output is enabled :param kwargs: Used to hand-over/overwrite default values. """ # pylint: disable=too-many-branches, too-many-statements if command_args is None: command_args = sys.argv[1:] elif isinstance(command_args, six.string_types): encoding = select_best_encoding() or "utf-8" if six.PY2 and isinstance(command_args, six.text_type): command_args = command_args.encode(encoding) elif six.PY3 and isinstance(command_args, six.binary_type): command_args = command_args.decode(encoding) command_args = shlex.split(command_args) elif isinstance(command_args, (list, tuple)): command_args = to_texts(command_args) if verbose is None: # -- AUTO-DISCOVER: Verbose mode from command-line args. verbose = ("-v" in command_args) or ("--verbose" in command_args) # Allow commands like `--color features/whizbang.feature` to work # Without this, argparse will treat the positional arg as the value to # --color and we'd get: # argument --color: invalid choice: 'features/whizbang.feature' # (choose from 'never', 'always', 'auto') if '--color' in command_args: color_arg_pos = command_args.index('--color') if os.path.exists(command_args[color_arg_pos + 1]): command_args.insert(color_arg_pos + 1, '--') self.version = None self.tags_help = None self.lang_list = None self.lang_help = None self.default_tags = None self.junit = None self.logging_format = None self.logging_datefmt = None self.name = None self.scope = None self.steps_catalog = None self.userdata = None self.wip = None defaults = self.defaults.copy() for name, value in six.iteritems(kwargs): defaults[name] = value self.defaults = defaults self.formatters = [] self.reporters = [] self.name_re = None self.outputs = [] self.include_re = None self.exclude_re = None self.scenario_outline_annotation_schema = None # pylint: disable=invalid-name self.steps_dir = "steps" self.environment_file = "environment.py" self.userdata_defines = None self.more_formatters = None if load_config: load_configuration(self.defaults, verbose=verbose) parser = setup_parser() parser.set_defaults(**self.defaults) args = parser.parse_args(command_args) for key, value in six.iteritems(args.__dict__): if key.startswith("_") and key not in self.cmdline_only_options: continue setattr(self, key, value) # -- ATTRIBUTE-NAME-CLEANUP: self.tag_expression = None self._tags = self.tags self.tags = None if isinstance(self.default_tags, six.string_types): self.default_tags = self.default_tags.split() self.paths = [os.path.normpath(path) for path in self.paths] self.setup_outputs(args.outfiles) if self.steps_catalog: # -- SHOW STEP-CATALOG: As step summary. self.default_format = "steps.catalog" if self.format: self.format.append("steps.catalog") else: self.format = ["steps.catalog"] self.dry_run = True self.summary = False self.show_skipped = False self.quiet = True if self.wip: # Only run scenarios tagged with "wip". # Additionally: # * use the "plain" formatter (per default) # * do not capture stdout or logging output and # * stop at the first failure. self.default_format = "plain" self._tags = ["wip"] + self.default_tags self.color = False self.stop = True self.log_capture = False self.stdout_capture = False self.tag_expression = make_tag_expression(self._tags or self.default_tags) # -- BACKWARD-COMPATIBLE (BAD-NAMING STYLE; deprecating): self.tags = self.tag_expression if self.quiet: self.show_source = False self.show_snippets = False if self.exclude_re: self.exclude_re = re.compile(self.exclude_re) if self.include_re: self.include_re = re.compile(self.include_re) if self.name: # -- SELECT: Scenario-by-name, build regular expression. self.name_re = self.build_name_re(self.name) if self.stage is None: # pylint: disable=access-member-before-definition # -- USE ENVIRONMENT-VARIABLE, if stage is undefined. self.stage = os.environ.get("BEHAVE_STAGE", None) self.setup_stage(self.stage) self.setup_model() self.setup_userdata() # -- FINALLY: Setup Reporters and Formatters # NOTE: Reporters and Formatters can now use userdata information. if self.junit: # Buffer the output (it will be put into Junit report) self.stdout_capture = True self.stderr_capture = True self.log_capture = True self.reporters.append(JUnitReporter(self)) if self.summary: self.reporters.append(SummaryReporter(self)) self.setup_formats() unknown_formats = self.collect_unknown_formats() if unknown_formats: parser.error("format=%s is unknown" % ", ".join(unknown_formats)) def setup_outputs(self, args_outfiles=None): if self.outputs: assert not args_outfiles, "ONLY-ONCE" return # -- NORMAL CASE: Setup only initially (once). if not args_outfiles: self.outputs.append(StreamOpener(stream=sys.stdout)) else: for outfile in args_outfiles: if outfile and outfile != "-": self.outputs.append(StreamOpener(outfile)) else: self.outputs.append(StreamOpener(stream=sys.stdout)) def setup_formats(self): """Register more, user-defined formatters by name.""" if self.more_formatters: for name, scoped_class_name in self.more_formatters.items(): _format_registry.register_as(name, scoped_class_name) def collect_unknown_formats(self): unknown_formats = [] if self.format: for format_name in self.format: if (format_name == "help" or _format_registry.is_formatter_valid(format_name)): continue unknown_formats.append(format_name) return unknown_formats @staticmethod def build_name_re(names): """ Build regular expression for scenario selection by name by using a list of name parts or name regular expressions. :param names: List of name parts or regular expressions (as text). :return: Compiled regular expression to use. """ # -- NOTE: re.LOCALE is removed in Python 3.6 (deprecated in Python 3.5) # flags = (re.UNICODE | re.LOCALE) # -- ENSURE: Names are all unicode/text values (for issue #606). names = to_texts(names) pattern = u"|".join(names) return re.compile(pattern, flags=re.UNICODE) def exclude(self, filename): if isinstance(filename, FileLocation): filename = six.text_type(filename) if self.include_re and self.include_re.search(filename) is None: return True if self.exclude_re and self.exclude_re.search(filename) is not None: return True return False def setup_logging(self, level=None, configfile=None, **kwargs): """ Support simple setup of logging subsystem. Ensures that the logging level is set. But note that the logging setup can only occur once. SETUP MODES: * :func:`logging.config.fileConfig()`, if ``configfile`` is provided. * :func:`logging.basicConfig()`, otherwise. .. code-block: python # -- FILE: features/environment.py def before_all(context): context.config.setup_logging() :param level: Logging level of root logger. If None, use :attr:`logging_level` value. :param configfile: Configuration filename for fileConfig() setup. :param kwargs: Passed to :func:`logging.basicConfig()` """ if level is None: level = self.logging_level # pylint: disable=no-member if configfile: from logging.config import fileConfig fileConfig(configfile) else: # pylint: disable=no-member format_ = kwargs.pop("format", self.logging_format) datefmt = kwargs.pop("datefmt", self.logging_datefmt) logging.basicConfig(format=format_, datefmt=datefmt, **kwargs) # -- ENSURE: Default log level is set # (even if logging subsystem is already configured). logging.getLogger().setLevel(level) def setup_model(self): if self.scenario_outline_annotation_schema: name_schema = six.text_type(self.scenario_outline_annotation_schema) ScenarioOutline.annotation_schema = name_schema.strip() def setup_stage(self, stage=None): """Setup the test stage that selects a different set of steps and environment implementations. :param stage: Name of current test stage (as string or None). EXAMPLE:: # -- SETUP DEFAULT TEST STAGE (unnamed): config = Configuration() config.setup_stage() assert config.steps_dir == "steps" assert config.environment_file == "environment.py" # -- SETUP PRODUCT TEST STAGE: config.setup_stage("product") assert config.steps_dir == "product_steps" assert config.environment_file == "product_environment.py" """ steps_dir = "steps" environment_file = "environment.py" if stage: # -- USE A TEST STAGE: Select different set of implementations. prefix = stage + "_" steps_dir = prefix + steps_dir environment_file = prefix + environment_file self.steps_dir = steps_dir self.environment_file = environment_file def setup_userdata(self): if not isinstance(self.userdata, UserData): self.userdata = UserData(self.userdata) if self.userdata_defines: # -- ENSURE: Cmd-line overrides configuration file parameters. self.userdata.update(self.userdata_defines) def update_userdata(self, data): """Update userdata with data and reapply userdata defines (cmdline). :param data: Provides (partial) userdata (as dict) """ self.userdata.update(data) if self.userdata_defines: # -- REAPPLY: Cmd-line defines (override configuration file data). self.userdata.update(self.userdata_defines)