busser-behave 0.1.3

data/vendor/behave/behave/contrib/scenario_autoretry.py

@@ -0,0 +1,73 @@
+# -*- coding: UTF -*-
+# pylint: disable=line-too-long
+"""
+Provides support functionality to retry scenarios a number of times before
+their failure is accepted. This functionality can be helpful when you use
+behave tests in a unreliable server/network infrastructure.
+
+EXAMPLE:
+
+.. sourcecode:: gherkin
+
+    # -- FILE: features/alice.feature
+    # TAG:  Feature or Scenario/ScenarioOutline with @autoretry
+    # NOTE: If you tag the feature, all its scenarios are retried.
+    @autoretry
+    Feature: Use unreliable Server infrastructure
+
+        Scenario: ...
+
+
+.. sourcecode:: python
+
+    # -- FILE: features/environment.py
+    from behave.contrib.scenario_autoretry import patch_scenario_with_autoretry
+
+    def before_feature(context, feature):
+        for scenario in feature.scenarios:
+            if "autoretry" in scenario.effective_tags:
+                patch_scenario_with_autoretry(scenario, max_attempts=2)
+
+.. seealso::
+    * https://github.com/behave/behave/pull/328
+    * https://github.com/hypothesis/smokey/blob/sauce-reliability/smokey/features/environment.py
+"""
+
+from __future__ import print_function
+import functools
+from behave.model import ScenarioOutline
+
+
+def patch_scenario_with_autoretry(scenario, max_attempts=3):
+    """Monkey-patches :func:`~behave.model.Scenario.run()` to auto-retry a
+    scenario that fails. The scenario is retried a number of times
+    before its failure is accepted.
+
+    This is helpful when the test infrastructure (server/network environment)
+    is unreliable (which should be a rare case).
+
+    :param scenario:        Scenario or ScenarioOutline to patch.
+    :param max_attempts:    How many times the scenario can be run.
+    """
+    def scenario_run_with_retries(scenario_run, *args, **kwargs):
+        for attempt in range(1, max_attempts+1):
+            if not scenario_run(*args, **kwargs):
+                if attempt > 1:
+                    message = u"AUTO-RETRY SCENARIO PASSED (after {0} attempts)"
+                    print(message.format(attempt))
+                return False    # -- NOT-FAILED = PASSED
+            # -- SCENARIO FAILED:
+            if attempt < max_attempts:
+                print(u"AUTO-RETRY SCENARIO (attempt {0})".format(attempt))
+        message = u"AUTO-RETRY SCENARIO FAILED (after {0} attempts)"
+        print(message.format(max_attempts))
+        return True
+
+    if isinstance(scenario, ScenarioOutline):
+        scenario_outline = scenario
+        for scenario in scenario_outline.scenarios:
+            scenario_run = scenario.run
+            scenario.run = functools.partial(scenario_run_with_retries, scenario_run)
+    else:
+        scenario_run = scenario.run
+        scenario.run = functools.partial(scenario_run_with_retries, scenario_run)

data/vendor/behave/behave/formatter/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+"""
+Root module for all behave formatters.
+"""
+
+from __future__ import absolute_import
+from behave.formatter import _builtins
+
+# -----------------------------------------------------------------------------
+# MODULE-INIT:
+# -----------------------------------------------------------------------------
+_builtins.setup_formatters()

data/vendor/behave/behave/formatter/_builtins.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""
+Knowledge base of all built-on formatters.
+"""
+
+from __future__ import  absolute_import
+from behave.formatter import _registry
+
+
+# -----------------------------------------------------------------------------
+# DATA:
+# -----------------------------------------------------------------------------
+# SCHEMA: formatter.name, formatter.class(_name)
+_BUILTIN_FORMATS = [
+    # pylint: disable=bad-whitespace
+    ("plain",   "behave.formatter.plain:PlainFormatter"),
+    ("pretty",  "behave.formatter.pretty:PrettyFormatter"),
+    ("json",    "behave.formatter.json:JSONFormatter"),
+    ("json.pretty", "behave.formatter.json:PrettyJSONFormatter"),
+    ("null",      "behave.formatter.null:NullFormatter"),
+    ("progress",  "behave.formatter.progress:ScenarioProgressFormatter"),
+    ("progress2", "behave.formatter.progress:StepProgressFormatter"),
+    ("progress3", "behave.formatter.progress:ScenarioStepProgressFormatter"),
+    ("rerun",     "behave.formatter.rerun:RerunFormatter"),
+    ("tags",          "behave.formatter.tags:TagsFormatter"),
+    ("tags.location", "behave.formatter.tags:TagsLocationFormatter"),
+    ("steps",         "behave.formatter.steps:StepsFormatter"),
+    ("steps.doc",     "behave.formatter.steps:StepsDocFormatter"),
+    ("steps.catalog", "behave.formatter.steps:StepsCatalogFormatter"),
+    ("steps.usage",   "behave.formatter.steps:StepsUsageFormatter"),
+    ("sphinx.steps",  "behave.formatter.sphinx_steps:SphinxStepsFormatter"),
+]
+
+# -----------------------------------------------------------------------------
+# FUNCTIONS:
+# -----------------------------------------------------------------------------
+def setup_formatters():
+    """Register all built-in formatters (lazy-loaded)."""
+    _registry.register_formats(_BUILTIN_FORMATS)

data/vendor/behave/behave/formatter/_registry.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+
+import sys
+import warnings
+from behave.formatter.base import Formatter, StreamOpener
+from behave.importer import LazyDict, LazyObject, parse_scoped_name, load_module
+import six
+
+
+# -----------------------------------------------------------------------------
+# FORMATTER REGISTRY:
+# -----------------------------------------------------------------------------
+_formatter_registry = LazyDict()
+
+def format_iter():
+    return iter(_formatter_registry.keys())
+
+def format_items(resolved=False):
+    if resolved:
+        # -- ENSURE: All formatter classes are loaded (and resolved).
+        _formatter_registry.load_all(strict=False)
+    return iter(_formatter_registry.items())
+
+def register_as(name, formatter_class):
+    """
+    Register formatter class with given name.
+
+    :param name:  Name for this formatter (as identifier).
+    :param formatter_class:  Formatter class to register.
+
+    .. since:: 1.2.5
+        Parameter ordering starts with name.
+    """
+    if not isinstance(name, six.string_types):
+        # -- REORDER-PARAMS: Used old ordering before behave-1.2.5 (2015).
+        warnings.warn("Use parameter ordering: name, formatter_class (for: %s)"\
+                      % formatter_class)
+        _formatter_class = name
+        name = formatter_class
+        formatter_class = _formatter_class
+
+    if isinstance(formatter_class, six.string_types):
+        # -- SPEEDUP-STARTUP: Only import formatter_class when used.
+        scoped_formatter_class_name = formatter_class
+        formatter_class = LazyObject(scoped_formatter_class_name)
+    assert (isinstance(formatter_class, LazyObject) or
+            issubclass(formatter_class, Formatter))
+    _formatter_registry[name] = formatter_class
+
+def register(formatter_class):
+    register_as(formatter_class.name, formatter_class)
+
+def register_formats(formats):
+    """Register many format items into the registry.
+
+    :param formats:  List of format items (as: (name, class|class_name)).
+    """
+    for formatter_name, formatter_class_name in formats:
+        register_as(formatter_name, formatter_class_name)
+
+def load_formatter_class(scoped_class_name):
+    """Load a formatter class by using its scoped class name.
+
+    :param scoped_class_name:  Formatter module and class name (as string).
+    :return: Formatter class.
+    :raises: ValueError, if scoped_class_name is invalid.
+    :raises: ImportError, if module cannot be loaded or class is not in module.
+    """
+    if ":" not in scoped_class_name:
+        message = 'REQUIRE: "module:class", but was: "%s"' % scoped_class_name
+        raise ValueError(message)
+    module_name, class_name = parse_scoped_name(scoped_class_name)
+    formatter_module = load_module(module_name)
+    formatter_class = getattr(formatter_module, class_name, None)
+    if formatter_class is None:
+        raise ImportError("CLASS NOT FOUND: %s" % scoped_class_name)
+    return formatter_class
+
+
+def select_formatter_class(formatter_name):
+    """Resolve the formatter class by:
+
+      * using one of the registered ones
+      * loading a user-specified formatter class (like: my.module_name:MyClass)
+
+    :param formatter_name:  Name of the formatter or scoped name (as string).
+    :return: Formatter class
+    :raises: LookupError, if not found.
+    :raises: ImportError, if a user-specific formatter class cannot be loaded.
+    :raises: ValueError, if formatter name is invalid.
+    """
+    try:
+        return _formatter_registry[formatter_name]
+    except KeyError:
+        # -- NOT-FOUND:
+        if ":" not in formatter_name:
+            raise
+        # -- OTHERWISE: SCOPED-NAME, try to load a user-specific formatter.
+        # MAY RAISE: ImportError
+        return load_formatter_class(formatter_name)
+
+
+def is_formatter_valid(formatter_name):
+    """Checks if the formatter is known (registered) or loadable.
+
+    :param formatter_name: Format(ter) name to check (as string).
+    :return: True, if formatter is known or can be loaded.
+    """
+    try:
+        formatter_class = select_formatter_class(formatter_name)
+        return issubclass(formatter_class, Formatter)
+    except (LookupError, ImportError, ValueError):
+        return False
+
+
+def make_formatters(config, stream_openers):
+    """Build a list of formatter, used by a behave runner.
+
+    :param config:  Configuration object to use.
+    :param stream_openers: List of stream openers to use (for formatters).
+    :return: List of formatters.
+    :raises: LookupError/KeyError if a formatter class is unknown.
+    :raises: ImportError, if a formatter class cannot be loaded/resolved.
+    """
+    # -- BUILD: Formatter list
+    default_stream_opener = StreamOpener(stream=sys.stdout)
+    formatter_list = []
+    for i, name in enumerate(config.format):
+        stream_opener = default_stream_opener
+        if i < len(stream_openers):
+            stream_opener = stream_openers[i]
+        formatter_class = select_formatter_class(name)
+        formatter_object = formatter_class(stream_opener, config)
+        formatter_list.append(formatter_object)
+    return formatter_list

data/vendor/behave/behave/formatter/ansi_escapes.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+"""
+Provides ANSI escape sequences for coloring/formatting output in ANSI terminals.
+"""
+
+from __future__ import absolute_import
+import os
+import re
+
+colors = {
+    "black":        u"\x1b[30m",
+    "red":          u"\x1b[31m",
+    "green":        u"\x1b[32m",
+    "yellow":       u"\x1b[33m",
+    "blue":         u"\x1b[34m",
+    "magenta":      u"\x1b[35m",
+    "cyan":         u"\x1b[36m",
+    "white":        u"\x1b[37m",
+    "grey":         u"\x1b[90m",
+    "bold":         u"\x1b[1m",
+}
+
+aliases = {
+    "untested":     "cyan",     # SAME-COLOR AS: skipped
+    "undefined":    "yellow",
+    "pending":      "yellow",
+    "executing":    "grey",
+    "failed":       "red",
+    "passed":       "green",
+    "outline":      "cyan",
+    "skipped":      "cyan",
+    "comments":     "grey",
+    "tag":          "cyan",
+}
+
+escapes = {
+    "reset":        u"\x1b[0m",
+    "up":           u"\x1b[1A",
+}
+
+if "GHERKIN_COLORS" in os.environ:
+    new_aliases = [p.split("=") for p in os.environ["GHERKIN_COLORS"].split(":")]
+    aliases.update(dict(new_aliases))
+
+for alias in aliases:
+    escapes[alias] = "".join([colors[c] for c in aliases[alias].split(",")])
+    arg_alias = alias + "_arg"
+    arg_seq = aliases.get(arg_alias, aliases[alias] + ",bold")
+    escapes[arg_alias] = "".join([colors[c] for c in arg_seq.split(",")])
+
+
+def up(n):
+    return u"\x1b[%dA" % n
+
+_ANSI_ESCAPE_PATTERN = re.compile(u"\x1b\[\d+[mA]", re.UNICODE)
+def strip_escapes(text):
+    """
+    Removes ANSI escape sequences from text (if any are contained).
+
+    :param text: Text that may or may not contain ANSI escape sequences.
+    :return: Text without ANSI escape sequences.
+    """
+    return _ANSI_ESCAPE_PATTERN.sub("", text)
+
+
+def use_ansi_escape_colorbold_composites():     # pragma: no cover
+    """
+    Patch for "sphinxcontrib-ansi" to process the following ANSI escapes
+    correctly (set-color set-bold sequences):
+
+        ESC[{color}mESC[1m  => ESC[{color};1m
+
+    Reapply aliases to ANSI escapes mapping.
+    """
+    # NOT-NEEDED: global escapes
+    color_codes = {}
+    for color_name, color_escape in colors.items():
+        color_code = color_escape.replace(u"\x1b[", u"").replace(u"m", u"")
+        color_codes[color_name] = color_code
+
+    # pylint: disable=redefined-outer-name
+    for alias in aliases:
+        parts = [color_codes[c] for c in aliases[alias].split(",")]
+        composite_escape = u"\x1b[{0}m".format(u";".join(parts))
+        escapes[alias] = composite_escape
+
+        arg_alias = alias + "_arg"
+        arg_seq = aliases.get(arg_alias, aliases[alias] + ",bold")
+        parts = [color_codes[c] for c in arg_seq.split(",")]
+        composite_escape = u"\x1b[{0}m".format(u";".join(parts))
+        escapes[arg_alias] = composite_escape

data/vendor/behave/behave/formatter/base.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+
+import codecs
+import os.path
+import six
+
+
+class StreamOpener(object):
+    """Provides a transport vehicle to open the formatter output stream
+    when the formatter needs it.
+    In addition, it provides the formatter with more control:
+
+      * when a stream is opened
+      * if a stream is opened at all
+      * the name (filename/dirname) of the output stream
+      * let it decide if directory mode is used instead of file mode
+    """
+    default_encoding = "UTF-8"
+
+    def __init__(self, filename=None, stream=None, encoding=None):
+        if not encoding:
+            encoding = self.default_encoding
+        if stream:
+            stream = self.ensure_stream_with_encoder(stream, encoding)
+        self.name = filename
+        self.stream = stream
+        self.encoding = encoding
+        self.should_close_stream = not stream   # Only for not pre-opened ones.
+
+    @staticmethod
+    def ensure_dir_exists(directory):
+        if directory and not os.path.isdir(directory):
+            os.makedirs(directory)
+
+    @classmethod
+    def ensure_stream_with_encoder(cls, stream, encoding=None):
+        if not encoding:
+            encoding = cls.default_encoding
+
+        if six.PY3:
+            return stream
+        elif hasattr(stream, "stream"):
+            return stream    # Already wrapped with a codecs.StreamWriter
+        else:
+            assert six.PY2
+            # py2 does, however, sometimes declare an encoding on sys.stdout,
+            # even if it doesn't use it (or it might be explicitly None)
+            stream = codecs.getwriter(encoding)(stream)
+        # elif not getattr(stream, 'encoding', None):
+        #     # -- TODO: POTENTIAL DEAD-CODE: Inspect and cleanup later.
+        #     # ok, so the stream doesn't have an encoding at all so add one
+        #     stream = codecs.getwriter(encoding)(stream)
+        return stream
+
+    def open(self):
+        if not self.stream or self.stream.closed:
+            self.ensure_dir_exists(os.path.dirname(self.name))
+            stream = open(self.name, "w")
+            # stream = codecs.open(self.name, "w", encoding=self.encoding)
+            stream = self.ensure_stream_with_encoder(stream, self.encoding)
+            self.stream = stream  # -- Keep stream for house-keeping.
+            self.should_close_stream = True
+            assert self.should_close_stream
+        return self.stream
+
+    def close(self):
+        """
+        Close the stream, if it was opened by this stream_opener.
+        Skip closing for sys.stdout and pre-opened streams.
+        :return: True, if stream was closed.
+        """
+        closed = False
+        if self.stream and self.should_close_stream:
+            closed = getattr(self.stream, "closed", False)
+            if not closed:
+                self.stream.close()
+                closed = True
+            self.stream = None
+        return closed
+
+
+class Formatter(object):
+    """
+    Base class for all formatter classes.
+    A formatter is an extension point (variation point) for the runner logic.
+    A formatter is called while processing model elements.
+
+    Processing Logic (simplified, without ScenarioOutline and skip logic)::
+
+        for feature in runner.features:
+            formatter = make_formatters(...)
+            formatter.uri(feature.filename)
+            formatter.feature(feature)
+            for scenario in feature.scenarios:
+                formatter.scenario(scenario)
+                for step in scenario.all_steps:
+                    formatter.step(step)
+                    step_match = step_registry.find_match(step)
+                    formatter.match(step_match)
+                    if step_match:
+                        step_match.run()
+                    else:
+                        step.status = Status.undefined
+                    formatter.result(step.status)
+            formatter.eof() # -- FEATURE-END
+        formatter.close()
+    """
+    name = None
+    description = None
+
+    def __init__(self, stream_opener, config):
+        self.stream_opener = stream_opener
+        self.stream = stream_opener.stream
+        self.config = config
+
+    @property
+    def stdout_mode(self):
+        return not self.stream_opener.name
+
+    def open(self):
+        """
+        Ensure that the output stream is open.
+        Triggers the stream opener protocol (if necessary).
+
+        :return: Output stream to use (just opened or already open).
+        """
+        if not self.stream:
+            self.stream = self.stream_opener.open()
+        return self.stream
+
+    def uri(self, uri):
+        """Called before processing a file (normally a feature file).
+
+        :param uri:  URI or filename (as string).
+        """
+        pass
+
+    def feature(self, feature):
+        """Called before a feature is executed.
+
+        :param feature:  Feature object (as :class:`behave.model.Feature`)
+        """
+        pass
+
+    def background(self, background):
+        """Called when a (Feature) Background is provided.
+        Called after :method:`feature()` is called.
+        Called before processing any scenarios or scenario outlines.
+
+        :param background:  Background object (as :class:`behave.model.Background`)
+        """
+        pass
+
+    def scenario(self, scenario):
+        """Called before a scenario is executed (or ScenarioOutline scenarios).
+
+        :param scenario:  Scenario object (as :class:`behave.model.Scenario`)
+        """
+        pass
+
+    def step(self, step):
+        """Called before a step is executed (and matched).
+        NOTE: Normally called before scenario is executed for all its steps.
+
+        :param step: Step object (as :class:`behave.model.Step`)
+        """
+
+    def match(self, match):
+        """Called when a step was matched against its step implementation.
+
+        :param match:  Registered step (as Match), undefined step (as NoMatch).
+        """
+        pass
+
+    def result(self, step_result):
+        """Called after processing a step (when the step result is known).
+
+        :param step_result:  Step result (as string-enum).
+        """
+        pass
+
+    def eof(self):
+        """Called after processing a feature (or a feature file)."""
+        pass
+
+    def close(self):
+        """Called before the formatter is no longer used
+        (stream/io compatibility).
+        """
+        self.close_stream()
+
+    def close_stream(self):
+        """Close the stream, but only if this is needed.
+        This step is skipped if the stream is sys.stdout.
+        """
+        if self.stream:
+            # -- DELEGATE STREAM-CLOSING: To stream_opener
+            assert self.stream is self.stream_opener.stream
+            self.stream_opener.close()
+        self.stream = None      # -- MARK CLOSED.