busser-behave 0.1.3

data/vendor/behave/behave/formatter/formatters.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""
+Deprecated module. Functionality was split-up into:
+
+  * behave.formatter._registry  (generic core functionality)
+  * behave.formatter._builtins  (registration of known, builtin formatters)
+
+.. since:: 1.2.5a1
+    Deprecated, use "behave.formatter._registry" or "behave.formatter._builtin".
+"""
+
+from __future__ import absolute_import
+import warnings
+from behave.formatter import _registry
+
+warnings.simplefilter("once", DeprecationWarning)
+warnings.warn("Use 'behave.formatter._registry' instead.", DeprecationWarning)
+
+# -----------------------------------------------------------------------------
+# FORMATTER REGISTRY:
+# -----------------------------------------------------------------------------
+def register_as(formatter_class, name):
+    """
+    Register formatter class with given name.
+
+    :param formatter_class:  Formatter class to register.
+    :param name:  Name for this formatter (as identifier).
+    """
+    warnings.warn("Use behave.formatter._registry.register_as() instead.",
+                  DeprecationWarning, stacklevel=2)
+    _registry.register_as(name, formatter_class)
+
+
+def register(formatter_class):
+    register_as(formatter_class, formatter_class.name)
+
+
+def get_formatter(config, stream_openers):
+    warnings.warn("Use make_formatters() instead",
+                  DeprecationWarning, stacklevel=2)
+    return _registry.make_formatters(config, stream_openers)
+
+
+# -----------------------------------------------------------------------------
+# SETUP:
+# -----------------------------------------------------------------------------
+def setup_formatters():
+    warnings.warn("Use behave.formatter._builtins instead",
+                  DeprecationWarning, stacklevel=2)
+    from behave.formatter import _builtins
+    _builtins.setup_formatters()
+
+
+# -----------------------------------------------------------------------------
+# MODULE-INIT:
+# -----------------------------------------------------------------------------
+# DISABLED: setup_formatters()

data/vendor/behave/behave/formatter/json.py

@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+"""
+This module provides `JSON`_ formatters for :mod:`behave`:
+
+* json: Generates compact JSON output
+* json.pretty: Generates readable JSON output
+
+.. _JSON: http://json.org
+"""
+
+from __future__ import absolute_import
+import base64
+from behave.formatter.base import Formatter
+from behave.model_core import Status
+import six
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+
+# -----------------------------------------------------------------------------
+# CLASS: JSONFormatter
+# -----------------------------------------------------------------------------
+class JSONFormatter(Formatter):
+    name = "json"
+    description = "JSON dump of test run"
+    dumps_kwargs = {}
+    split_text_into_lines = True   # EXPERIMENT for better readability.
+
+    json_number_types = six.integer_types + (float,)
+    json_scalar_types = json_number_types + (six.text_type, bool, type(None))
+
+    def __init__(self, stream_opener, config):
+        super(JSONFormatter, self).__init__(stream_opener, config)
+        # -- ENSURE: Output stream is open.
+        self.stream = self.open()
+        self.feature_count = 0
+        self.current_feature = None
+        self.current_feature_data = None
+        self.current_scenario = None
+        self._step_index = 0
+
+    def reset(self):
+        self.current_feature = None
+        self.current_feature_data = None
+        self.current_scenario = None
+        self._step_index = 0
+
+    # -- FORMATTER API:
+    def uri(self, uri):
+        pass
+
+    def feature(self, feature):
+        self.reset()
+        self.current_feature = feature
+        self.current_feature_data = {
+            "keyword": feature.keyword,
+            "name": feature.name,
+            "tags": list(feature.tags),
+            "location": six.text_type(feature.location),
+            "status": None,     # Not known before feature run.
+        }
+        element = self.current_feature_data
+        if feature.description:
+            element["description"] = feature.description
+
+    def background(self, background):
+        element = self.add_feature_element({
+            "type": "background",
+            "keyword": background.keyword,
+            "name": background.name,
+            "location": six.text_type(background.location),
+            "steps": [],
+        })
+        if background.name:
+            element["name"] = background.name
+        self._step_index = 0
+
+        # -- ADD BACKGROUND STEPS: Support *.feature file regeneration.
+        for step_ in background.steps:
+            self.step(step_)
+
+    def scenario(self, scenario):
+        self.finish_current_scenario()
+        self.current_scenario = scenario
+
+        element = self.add_feature_element({
+            "type": "scenario",
+            "keyword": scenario.keyword,
+            "name": scenario.name,
+            "tags": scenario.tags,
+            "location": six.text_type(scenario.location),
+            "steps": [],
+            "status": None,
+        })
+        if scenario.description:
+            element["description"] = scenario.description
+        self._step_index = 0
+
+    @classmethod
+    def make_table(cls, table):
+        table_data = {
+            "headings": table.headings,
+            "rows": [list(row) for row in table.rows]
+        }
+        return table_data
+
+    def step(self, step):
+        s = {
+            "keyword": step.keyword,
+            "step_type": step.step_type,
+            "name": step.name,
+            "location": six.text_type(step.location),
+        }
+
+        if step.text:
+            text = step.text
+            if self.split_text_into_lines and "\n" in text:
+                text = text.splitlines()
+            s["text"] = text
+        if step.table:
+            s["table"] = self.make_table(step.table)
+        element = self.current_feature_element
+        element["steps"].append(s)
+
+    def match(self, match):
+        args = []
+        for argument in match.arguments:
+            argument_value = argument.value
+            if not isinstance(argument_value, self.json_scalar_types):
+                # -- OOPS: Avoid invalid JSON format w/ custom types.
+                # Use raw string (original) instead.
+                argument_value = argument.original
+            assert isinstance(argument_value, self.json_scalar_types)
+            arg = {
+                "value": argument_value,
+            }
+            if argument.name:
+                arg["name"] = argument.name
+            if argument.original != argument_value:
+                # -- REDUNDANT DATA COMPRESSION: Suppress for strings.
+                arg["original"] = argument.original
+            args.append(arg)
+
+        match_data = {
+            "location": six.text_type(match.location) or "",
+            "arguments": args,
+        }
+        if match.location:
+            # -- NOTE: match.location=None occurs for undefined steps.
+            steps = self.current_feature_element["steps"]
+            steps[self._step_index]["match"] = match_data
+
+    def result(self, result):
+        steps = self.current_feature_element["steps"]
+        steps[self._step_index]["result"] = {
+            "status": result.status.name,
+            "duration": result.duration,
+        }
+        if result.error_message and result.status == Status.failed:
+            # -- OPTIONAL: Provided for failed steps.
+            error_message = result.error_message
+            if self.split_text_into_lines and "\n" in error_message:
+                error_message = error_message.splitlines()
+            result_element = steps[self._step_index]["result"]
+            result_element["error_message"] = error_message
+        self._step_index += 1
+
+    def embedding(self, mime_type, data):
+        step = self.current_feature_element["steps"][-1]
+        step["embeddings"].append({
+            "mime_type": mime_type,
+            "data": base64.b64encode(data).replace("\n", ""),
+        })
+
+    def eof(self):
+        """
+        End of feature
+        """
+        if not self.current_feature_data:
+            return
+
+        # -- NORMAL CASE: Write collected data of current feature.
+        self.finish_current_scenario()
+        self.update_status_data()
+
+        if self.feature_count == 0:
+            # -- FIRST FEATURE:
+            self.write_json_header()
+        else:
+            # -- NEXT FEATURE:
+            self.write_json_feature_separator()
+
+        self.write_json_feature(self.current_feature_data)
+        self.reset()
+        self.feature_count += 1
+
+    def close(self):
+        if self.feature_count == 0:
+            # -- FIRST FEATURE: Corner case when no features are provided.
+            self.write_json_header()
+        self.write_json_footer()
+        self.close_stream()
+
+    # -- JSON-DATA COLLECTION:
+    def add_feature_element(self, element):
+        assert self.current_feature_data is not None
+        if "elements" not in self.current_feature_data:
+            self.current_feature_data["elements"] = []
+        self.current_feature_data["elements"].append(element)
+        return element
+
+    @property
+    def current_feature_element(self):
+        assert self.current_feature_data is not None
+        return self.current_feature_data["elements"][-1]
+
+    def update_status_data(self):
+        assert self.current_feature
+        assert self.current_feature_data
+        self.current_feature_data["status"] = self.current_feature.status.name
+
+    def finish_current_scenario(self):
+        if self.current_scenario:
+            status_name = self.current_scenario.status.name
+            self.current_feature_element["status"] = status_name
+
+    # -- JSON-WRITER:
+    def write_json_header(self):
+        self.stream.write("[\n")
+
+    def write_json_footer(self):
+        self.stream.write("\n]\n")
+
+    def write_json_feature(self, feature_data):
+        self.stream.write(json.dumps(feature_data, **self.dumps_kwargs))
+        self.stream.flush()
+
+    def write_json_feature_separator(self):
+        self.stream.write(",\n\n")
+
+
+# -----------------------------------------------------------------------------
+# CLASS: PrettyJSONFormatter
+# -----------------------------------------------------------------------------
+class PrettyJSONFormatter(JSONFormatter):
+    """
+    Provides readable/comparable textual JSON output.
+    """
+    name = "json.pretty"
+    description = "JSON dump of test run (human readable)"
+    dumps_kwargs = {"indent": 2, "sort_keys": True}

data/vendor/behave/behave/formatter/null.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from behave.formatter.base import Formatter
+
+class NullFormatter(Formatter):
+    """
+    Provides formatter that does not output anything.
+    Implements the NULL pattern for a formatter (similar like: /dev/null).
+    """
+    name = "null"
+    description = "Provides formatter that does not output anything."

data/vendor/behave/behave/formatter/plain.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+from behave.formatter.base import Formatter
+from behave.model_describe import ModelPrinter
+from behave.textutil import make_indentation
+
+
+# -----------------------------------------------------------------------------
+# CLASS: PlainFormatter
+# -----------------------------------------------------------------------------
+class PlainFormatter(Formatter):
+    """
+    Provides a simple plain formatter without coloring/formatting.
+    The formatter displays now also:
+
+       * multi-line text (doc-strings)
+       * table
+       * tags (maybe)
+    """
+    name = "plain"
+    description = "Very basic formatter with maximum compatibility"
+
+    SHOW_MULTI_LINE = True
+    SHOW_TAGS = False
+    SHOW_ALIGNED_KEYWORDS = False
+    DEFAULT_INDENT_SIZE = 2
+    RAISE_OUTPUT_ERRORS = True
+
+    def __init__(self, stream_opener, config, **kwargs):
+        super(PlainFormatter, self).__init__(stream_opener, config)
+        self.steps = []
+        self.show_timings = config.show_timings
+        self.show_multiline = config.show_multiline and self.SHOW_MULTI_LINE
+        self.show_aligned_keywords = self.SHOW_ALIGNED_KEYWORDS
+        self.show_tags = self.SHOW_TAGS
+        self.indent_size = self.DEFAULT_INDENT_SIZE
+        # -- ENSURE: Output stream is open.
+        self.stream = self.open()
+        self.printer = ModelPrinter(self.stream)
+        # -- LAZY-EVALUATE:
+        self._multiline_indentation = None
+
+    @property
+    def multiline_indentation(self):
+        if self._multiline_indentation is None:
+            offset = 0
+            if self.show_aligned_keywords:
+                offset = 2
+            indentation = make_indentation(3 * self.indent_size + offset)
+            self._multiline_indentation = indentation
+        return self._multiline_indentation
+
+    def reset_steps(self):
+        self.steps = []
+
+    def write_tags(self, tags, indent=None):
+        if tags and self.show_tags:
+            indent = indent or ""
+            text = " @".join(tags)
+            self.stream.write(u"%s@%s\n" % (indent, text))
+
+    # -- IMPLEMENT-INTERFACE FOR: Formatter
+    def feature(self, feature):
+        self.reset_steps()
+        self.write_tags(feature.tags)
+        self.stream.write(u"%s: %s\n" % (feature.keyword, feature.name))
+
+    def background(self, background):
+        self.reset_steps()
+        indent = make_indentation(self.indent_size)
+        text = u"%s%s: %s\n" % (indent, background.keyword, background.name)
+        self.stream.write(text)
+
+    def scenario(self, scenario):
+        self.reset_steps()
+        self.stream.write(u"\n")
+        indent = make_indentation(self.indent_size)
+        text = u"%s%s: %s\n" % (indent, scenario.keyword, scenario.name)
+        self.write_tags(scenario.tags, indent)
+        self.stream.write(text)
+
+    def step(self, step):
+        self.steps.append(step)
+
+    def result(self, result):
+        """
+        Process the result of a step (after step execution).
+
+        :param result:
+        """
+        step = self.steps.pop(0)
+        indent = make_indentation(2 * self.indent_size)
+        if self.show_aligned_keywords:
+            # -- RIGHT-ALIGN KEYWORDS (max. keyword width: 6):
+            text = u"%s%6s %s ... " % (indent, step.keyword, step.name)
+        else:
+            text = u"%s%s %s ... " % (indent, step.keyword, step.name)
+        self.stream.write(text)
+
+        status_text = result.status.name
+        if self.show_timings:
+            status_text += " in %0.3fs" % step.duration
+
+        unicode_errors = 0
+        if result.error_message:
+            try:
+                self.stream.write(u"%s\n%s\n" % (status_text, result.error_message))
+            except UnicodeError as e:
+                unicode_errors += 1
+                self.stream.write(u"%s\n" % status_text)
+                self.stream.write(u"%s while writing error message: %s\n" % \
+                                  (e.__class__.__name__, e))
+                if self.RAISE_OUTPUT_ERRORS:
+                    raise
+        else:
+            self.stream.write(u"%s\n" % status_text)
+
+        if self.show_multiline:
+            if step.text:
+                try:
+                    self.doc_string(step.text)
+                except UnicodeError as e:
+                    unicode_errors += 1
+                    self.stream.write(u"%s while writing docstring: %s\n" % \
+                                      (e.__class__.__name__, e))
+                    if self.RAISE_OUTPUT_ERRORS:
+                        raise
+            if step.table:
+                self.table(step.table)
+
+    def eof(self):
+        self.stream.write("\n")
+
+    # -- MORE: Formatter helpers
+    def doc_string(self, doc_string):
+        self.printer.print_docstring(doc_string, self.multiline_indentation)
+
+    def table(self, table):
+        self.printer.print_table(table, self.multiline_indentation)
+
+
+# -----------------------------------------------------------------------------
+# CLASS: Plain0Formatter
+# -----------------------------------------------------------------------------
+class Plain0Formatter(PlainFormatter):
+    """
+    Similar to old plain formatter without support for:
+
+      * multi-line text
+      * tables
+      * tags
+    """
+    name = "plain0"
+    description = "Very basic formatter with maximum compatibility"
+    SHOW_MULTI_LINE = False
+    SHOW_TAGS = False
+    SHOW_ALIGNED_KEYWORDS = False