busser-behave 0.1.3

data/vendor/behave/behave/formatter/pretty.py

@@ -0,0 +1,351 @@
+# -*- coding: utf8 -*-
+
+from __future__ import absolute_import, division
+import sys
+from behave.formatter.ansi_escapes import escapes, up
+from behave.formatter.base import Formatter
+from behave.model_core import Status
+from behave.model_describe import escape_cell, escape_triple_quotes
+from behave.textutil import indent, text as _text
+import six
+from six.moves import range, zip
+
+
+# -----------------------------------------------------------------------------
+# TERMINAL SUPPORT:
+# -----------------------------------------------------------------------------
+DEFAULT_WIDTH = 80
+DEFAULT_HEIGHT = 24
+
+def get_terminal_size():
+    if sys.platform == "windows":
+        # Autodetecting the size of a Windows command window is left as an
+        # exercise for the reader. Prizes may be awarded for the best answer.
+        return (DEFAULT_WIDTH, DEFAULT_HEIGHT)
+
+    try:
+        import fcntl
+        import termios
+        import struct
+
+        zero_struct = struct.pack("HHHH", 0, 0, 0, 0)
+        result = fcntl.ioctl(0, termios.TIOCGWINSZ, zero_struct)
+        h, w, hp1, wp1 = struct.unpack("HHHH", result)
+
+        return w or DEFAULT_WIDTH, h or DEFAULT_HEIGHT
+    except Exception:   # pylint: disable=broad-except
+        return (DEFAULT_WIDTH, DEFAULT_HEIGHT)
+
+
+# -----------------------------------------------------------------------------
+# COLORING SUPPORT:
+# -----------------------------------------------------------------------------
+class MonochromeFormat(object):
+    def text(self, text):   # pylint: disable=no-self-use
+        assert isinstance(text, six.text_type)
+        return text
+
+class ColorFormat(object):
+    def __init__(self, status):
+        self.status = status
+
+    def text(self, text):
+        assert isinstance(text, six.text_type)
+        return escapes[self.status] + text + escapes["reset"]
+
+
+# -----------------------------------------------------------------------------
+# CLASS: PrettyFormatter
+# -----------------------------------------------------------------------------
+class PrettyFormatter(Formatter):
+    # pylint: disable=too-many-instance-attributes
+    name = "pretty"
+    description = "Standard colourised pretty formatter"
+
+    def __init__(self, stream_opener, config):
+        super(PrettyFormatter, self).__init__(stream_opener, config)
+        # -- ENSURE: Output stream is open.
+        self.stream = self.open()
+        isatty = getattr(self.stream, "isatty", lambda: True)
+        stream_supports_colors = isatty()
+        self.monochrome = not config.color or not stream_supports_colors
+        self.show_source = config.show_source
+        self.show_timings = config.show_timings
+        self.show_multiline = config.show_multiline
+        self.formats = None
+        self.display_width = get_terminal_size()[0]
+
+        # -- UNUSED: self.tag_statement = None
+        self.steps = []
+        self._uri = None
+        self._match = None
+        self.statement = None
+        self.indentations = []
+        self.step_lines = 0
+
+
+    def reset(self):
+        # -- UNUSED: self.tag_statement = None
+        self.steps = []
+        self._uri = None
+        self._match = None
+        self.statement = None
+        self.indentations = []
+        self.step_lines = 0
+
+    def uri(self, uri):
+        self.reset()
+        self._uri = uri
+
+    def feature(self, feature):
+        #self.print_comments(feature.comments, '')
+        self.print_tags(feature.tags, '')
+        self.stream.write(u"%s: %s" % (feature.keyword, feature.name))
+        if self.show_source:
+            # pylint: disable=redefined-builtin
+            format = self.format("comments")
+            self.stream.write(format.text(u" # %s" % feature.location))
+        self.stream.write("\n")
+        self.print_description(feature.description, "  ", False)
+        self.stream.flush()
+
+    def background(self, background):
+        self.replay()
+        self.statement = background
+
+    def scenario(self, scenario):
+        self.replay()
+        self.statement = scenario
+
+    def replay(self):
+        self.print_statement()
+        self.print_steps()
+        self.stream.flush()
+
+    def step(self, step):
+        self.steps.append(step)
+
+    def match(self, match):
+        self._match = match
+        self.print_statement()
+        self.print_step(Status.executing, self._match.arguments,
+                        self._match.location, self.monochrome)
+        self.stream.flush()
+
+    def result(self, result):
+        if not self.monochrome:
+            lines = self.step_lines + 1
+            if self.show_multiline:
+                if result.table:
+                    lines += len(result.table.rows) + 1
+                if result.text:
+                    lines += len(result.text.splitlines()) + 2
+            self.stream.write(up(lines))
+            arguments = []
+            location = None
+            if self._match:
+                arguments = self._match.arguments
+                location = self._match.location
+            self.print_step(result.status, arguments, location, True)
+        if result.error_message:
+            self.stream.write(indent(result.error_message.strip(), u"      "))
+            self.stream.write("\n\n")
+        self.stream.flush()
+
+    def arg_format(self, key):
+        return self.format(key + "_arg")
+
+    def format(self, key):
+        if self.monochrome:
+            if self.formats is None:
+                self.formats = MonochromeFormat()
+            return self.formats
+        # -- OTHERWISE:
+        if self.formats is None:
+            self.formats = {}   # pylint: disable=redefined-variable-type
+        # pylint: disable=redefined-builtin
+        format = self.formats.get(key, None)
+        if format is not None:
+            return format
+        format = self.formats[key] = ColorFormat(key)
+        return format
+
+    def eof(self):
+        self.replay()
+        self.stream.write("\n")
+        self.stream.flush()
+
+    def table(self, table):
+        cell_lengths = []
+        all_rows = [table.headings] + table.rows
+        for row in all_rows:
+            lengths = [len(escape_cell(c)) for c in row]
+            cell_lengths.append(lengths)
+
+        max_lengths = []
+        for col in range(0, len(cell_lengths[0])):
+            max_lengths.append(max([c[col] for c in cell_lengths]))
+
+        for i, row in enumerate(all_rows):
+            #for comment in row.comments:
+            #    self.stream.write("      %s\n" % comment.value)
+            self.stream.write("      |")
+            for j, (cell, max_length) in enumerate(zip(row, max_lengths)):
+                self.stream.write(" ")
+                self.stream.write(self.color(cell, None, j))
+                self.stream.write(" " * (max_length - cell_lengths[i][j]))
+                self.stream.write(" |")
+            self.stream.write("\n")
+        self.stream.flush()
+
+    def doc_string(self, doc_string):
+        #self.stream.write('      """' + doc_string.content_type + '\n')
+        doc_string = _text(doc_string)
+        prefix = u"      "
+        self.stream.write(u'%s"""\n' % prefix)
+        doc_string = escape_triple_quotes(indent(doc_string, prefix))
+        self.stream.write(doc_string)
+        self.stream.write(u'\n%s"""\n' % prefix)
+        self.stream.flush()
+
+    # def doc_string(self, doc_string):
+    #     from behave.model_describe import ModelDescriptor
+    #     prefix = "      "
+    #     text = ModelDescriptor.describe_docstring(doc_string, prefix)
+    #     self.stream.write(text)
+    #     self.stream.flush()
+
+    # -- UNUSED:
+    # def exception(self, exception):
+    #     exception_text = _text(exception)
+    #     self.stream.write(self.format("failed").text(exception_text) + "\n")
+    #     self.stream.flush()
+
+    def color(self, cell, statuses, _color):  # pylint: disable=no-self-use
+        if statuses:
+            return escapes["color"] + escapes["reset"]
+        else:
+            return escape_cell(cell)
+
+    def indented_text(self, text, proceed):
+        if not text:
+            return u""
+
+        if proceed:
+            indentation = self.indentations.pop(0)
+        else:
+            indentation = self.indentations[0]
+
+        indentation = u" " * indentation
+        return u"%s # %s" % (indentation, text)
+
+    def calculate_location_indentations(self):
+        line_widths = []
+        for s in [self.statement] + self.steps:
+            string = s.keyword + " " + s.name
+            line_widths.append(len(string))
+        max_line_width = max(line_widths)
+        self.indentations = [max_line_width - width for width in line_widths]
+
+    def print_statement(self):
+        if self.statement is None:
+            return
+
+        self.calculate_location_indentations()
+        self.stream.write(u"\n")
+        #self.print_comments(self.statement.comments, "  ")
+        if hasattr(self.statement, "tags"):
+            self.print_tags(self.statement.tags, u"  ")
+        self.stream.write(u"  %s: %s " % (self.statement.keyword,
+                                          self.statement.name))
+
+        location = self.indented_text(six.text_type(self.statement.location), True)
+        if self.show_source:
+            self.stream.write(self.format("comments").text(location))
+        self.stream.write("\n")
+        #self.print_description(self.statement.description, u"    ")
+        self.statement = None
+
+    def print_steps(self):
+        while self.steps:
+            self.print_step(Status.skipped, [], None, True)
+
+    def print_step(self, status, arguments, location, proceed):
+        if proceed:
+            step = self.steps.pop(0)
+        else:
+            step = self.steps[0]
+
+        text_format = self.format(status.name)
+        arg_format = self.arg_format(status.name)
+
+        #self.print_comments(step.comments, "    ")
+        self.stream.write("    ")
+        self.stream.write(text_format.text(step.keyword + " "))
+        line_length = 5 + len(step.keyword)
+
+        step_name = six.text_type(step.name)
+
+        text_start = 0
+        for arg in arguments:
+            if arg.end <= text_start:
+                # -- SKIP-OVER: Optional and nested regexp args
+                #    - Optional regexp args (unmatched: None).
+                #    - Nested regexp args that are already processed.
+                continue
+                # -- VALID, MATCHED ARGUMENT:
+            assert arg.original is not None
+            text = step_name[text_start:arg.start]
+            self.stream.write(text_format.text(text))
+            line_length += len(text)
+            self.stream.write(arg_format.text(arg.original))
+            line_length += len(arg.original)
+            text_start = arg.end
+
+        if text_start != len(step_name):
+            text = step_name[text_start:]
+            self.stream.write(text_format.text(text))
+            line_length += (len(text))
+
+        if self.show_source:
+            location = six.text_type(location)
+            if self.show_timings and status in (Status.passed, Status.failed):
+                location += " %0.3fs" % step.duration
+            location = self.indented_text(location, proceed)
+            self.stream.write(self.format("comments").text(location))
+            line_length += len(location)
+        elif self.show_timings and status in (Status.passed, Status.failed):
+            timing = "%0.3fs" % step.duration
+            timing = self.indented_text(timing, proceed)
+            self.stream.write(self.format("comments").text(timing))
+            line_length += len(timing)
+        self.stream.write("\n")
+
+        self.step_lines = int((line_length - 1) / self.display_width)
+
+        if self.show_multiline:
+            if step.text:
+                self.doc_string(step.text)
+            if step.table:
+                self.table(step.table)
+
+    def print_tags(self, tags, indentation):
+        if not tags:
+            return
+        line = " ".join("@" + tag for tag in tags)
+        self.stream.write(indentation + line + "\n")
+
+    def print_comments(self, comments, indentation):
+        if not comments:
+            return
+
+        self.stream.write(indent([c.value for c in comments], indentation))
+        self.stream.write("\n")
+
+    def print_description(self, description, indentation, newline=True):
+        if not description:
+            return
+
+        self.stream.write(indent(description, indentation))
+        if newline:
+            self.stream.write("\n")

data/vendor/behave/behave/formatter/progress.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+"""
+Provides 2 dotted progress formatters:
+
+  * ScenarioProgressFormatter (scope: scenario)
+  * StepProgressFormatter (scope: step)
+
+A "dot" character that represents the result status is printed after
+executing a scope item.
+"""
+
+from __future__ import absolute_import
+import six
+from behave.formatter.base import Formatter
+from behave.model_core import Status
+from behave.textutil import text as _text
+
+
+# -----------------------------------------------------------------------------
+# CLASS: ProgressFormatterBase
+# -----------------------------------------------------------------------------
+class ProgressFormatterBase(Formatter):
+    """
+    Provides formatter base class for different variants of progress formatters.
+    A progress formatter show an abbreviated, compact dotted progress bar,
+    similar to unittest output (in terse mode).
+    """
+    # -- MAP: step.status to short dot_status representation.
+    dot_status = {
+        "passed":    ".",
+        "failed":    "F",
+        "error":     "E",   # Caught exception, but not an AssertionError
+        "skipped":   "S",
+        "untested":  "_",
+        "undefined": "U",
+    }
+    show_timings = False
+
+    def __init__(self, stream_opener, config):
+        super(ProgressFormatterBase, self).__init__(stream_opener, config)
+        # -- ENSURE: Output stream is open.
+        self.stream = self.open()
+        self.steps = []
+        self.failures = []
+        self.current_feature = None
+        self.current_scenario = None
+        self.show_timings = config.show_timings and self.show_timings
+
+    def reset(self):
+        self.steps = []
+        self.failures = []
+        self.current_feature = None
+        self.current_scenario = None
+
+    # -- FORMATTER API:
+    def feature(self, feature):
+        self.current_feature = feature
+        self.stream.write("%s  " % six.text_type(feature.filename))
+        self.stream.flush()
+
+    def background(self, background):
+        pass
+
+    def scenario(self, scenario):
+        """
+        Process the next scenario.
+        But first allow to report the status on the last scenario.
+        """
+        self.report_scenario_completed()
+        self.current_scenario = scenario
+
+    def step(self, step):
+        self.steps.append(step)
+
+    def result(self, result):
+        self.steps.pop(0)
+        self.report_step_progress(result)
+
+    def eof(self):
+        """
+        Called at end of a feature.
+        It would be better to have a hook that is called after all features.
+        """
+        self.report_scenario_completed()
+        self.report_feature_completed()
+        self.report_failures()
+        self.stream.flush()
+        self.reset()
+
+    # -- SPECIFIC PART:
+    def report_step_progress(self, result):
+        """
+        Report the progress on the current step.
+        The default implementation is empty.
+        It should be override by a concrete class.
+        """
+        pass
+
+    def report_scenario_progress(self):
+        """
+        Report the progress for the current/last scenario.
+        The default implementation is empty.
+        It should be override by a concrete class.
+        """
+        pass
+
+    def report_feature_completed(self):
+        """Hook called when a feature is completed to perform the last tasks.
+        """
+        pass
+
+    def report_scenario_completed(self):
+        """Hook called when a scenario is completed to perform the last tasks.
+        """
+        self.report_scenario_progress()
+
+    def report_feature_duration(self):
+        if self.show_timings and self.current_feature:
+            self.stream.write(u"  # %.3fs" % self.current_feature.duration)
+        self.stream.write("\n")
+
+    def report_scenario_duration(self):
+        if self.show_timings and self.current_scenario:
+            self.stream.write(u"  # %.3fs" % self.current_scenario.duration)
+        self.stream.write("\n")
+
+    def report_failures(self):
+        if self.failures:
+            separator = "-" * 80
+            self.stream.write(u"%s\n" % separator)
+            for result in self.failures:
+                self.stream.write(u"FAILURE in step '%s':\n" % result.name)
+                self.stream.write(u"  Feature:  %s\n" % result.feature.name)
+                self.stream.write(u"  Scenario: %s\n" % result.scenario.name)
+                self.stream.write(u"%s\n" % result.error_message)
+                if result.exception:
+                    self.stream.write(u"exception: %s\n" % result.exception)
+            self.stream.write(u"%s\n" % separator)
+
+
+# -----------------------------------------------------------------------------
+# CLASS: ScenarioProgressFormatter
+# -----------------------------------------------------------------------------
+class ScenarioProgressFormatter(ProgressFormatterBase):
+    """
+    Report dotted progress for each scenario similar to unittest.
+    """
+    name = "progress"
+    description = "Shows dotted progress for each executed scenario."
+
+    def report_scenario_progress(self):
+        """
+        Report the progress for the current/last scenario.
+        """
+        if not self.current_scenario:
+            return  # SKIP: No results to report for first scenario.
+        # -- NORMAL-CASE:
+        status_name = self.current_scenario.status.name
+        dot_status = self.dot_status[status_name]
+        if status_name == "failed":
+            # MAYBE TODO: self.failures.append(result)
+            pass
+        self.stream.write(dot_status)
+        self.stream.flush()
+
+    def report_feature_completed(self):
+        self.report_feature_duration()
+
+# -----------------------------------------------------------------------------
+# CLASS: StepProgressFormatter
+# -----------------------------------------------------------------------------
+class StepProgressFormatter(ProgressFormatterBase):
+    """
+    Report dotted progress for each step similar to unittest.
+    """
+    name = "progress2"
+    description = "Shows dotted progress for each executed step."
+
+    def report_step_progress(self, result):
+        """
+        Report the progress for each step.
+        """
+        dot_status = self.dot_status[result.status.name]
+        if result.status == Status.failed:
+            if (result.exception and
+                    not isinstance(result.exception, AssertionError)):
+                # -- ISA-ERROR: Some Exception
+                dot_status = self.dot_status["error"]
+            result.feature = self.current_feature
+            result.scenario = self.current_scenario
+            self.failures.append(result)
+        self.stream.write(dot_status)
+        self.stream.flush()
+
+    def report_feature_completed(self):
+        self.report_feature_duration()
+
+
+# -----------------------------------------------------------------------------
+# CLASS: ScenarioStepProgressFormatter
+# -----------------------------------------------------------------------------
+class ScenarioStepProgressFormatter(StepProgressFormatter):
+    """
+    Shows detailed dotted progress for both each step of a scenario.
+    Differs from StepProgressFormatter by:
+
+      * showing scenario names (as prefix scenario step progress)
+      * showing failures after each scenario (if necessary)
+
+    EXAMPLE:
+        $ behave -f progress3 features
+        Feature with failing scenario    # features/failing_scenario.feature
+            Simple scenario with last failing step  ....F
+        -----------------------------------------------------------------------
+        FAILURE in step 'last step fails' (features/failing_scenario.feature:7):
+        Assertion Failed: xxx
+        -----------------------------------------------------------------------
+    """
+    name = "progress3"
+    description = "Shows detailed progress for each step of a scenario."
+    indent_size = 2
+    scenario_prefix = " " * indent_size
+
+    # -- FORMATTER API:
+    def feature(self, feature):
+        self.current_feature = feature
+        self.stream.write(u"%s    # %s" % (feature.name, feature.filename))
+
+    def scenario(self, scenario):
+        """Process the next scenario."""
+        # -- LAST SCENARIO: Report failures (if any).
+        self.report_scenario_completed()
+
+        # -- NEW SCENARIO:
+        assert not self.failures
+        self.current_scenario = scenario
+        scenario_name = scenario.name
+        if scenario_name:
+            scenario_name += " "
+        self.stream.write(u"%s%s " % (self.scenario_prefix, scenario_name))
+        self.stream.flush()
+
+    # -- DISABLED:
+    # def eof(self):
+    #     has_scenarios = self.current_feature and self.current_scenario
+    #     super(ScenarioStepProgressFormatter, self).eof()
+    #     if has_scenarios:
+    #         # -- EMPTY-LINE between 2 features.
+    #         self.stream.write("\n")
+
+    # -- PROGRESS FORMATTER DETAILS:
+    # @overriden
+    def report_feature_completed(self):
+        # -- SKIP: self.report_feature_duration()
+        has_scenarios = self.current_feature and self.current_scenario
+        if has_scenarios:
+            # -- EMPTY-LINE between 2 features.
+            self.stream.write("\n")
+
+    def report_scenario_completed(self):
+        self.report_scenario_progress()
+        self.report_scenario_duration()
+        self.report_failures()
+        self.failures = []
+
+    def report_failures(self):
+        if self.failures:
+            separator = "-" * 80
+            self.stream.write(u"%s\n" % separator)
+            unicode_errors = 0
+            for failure in self.failures:
+                try:
+                    self.stream.write(u"FAILURE in step '%s' (%s):\n" % \
+                                      (failure.name, failure.location))
+                    self.stream.write(u"%s\n" % failure.error_message)
+                    self.stream.write(u"%s\n" % separator)
+                except UnicodeError as e:
+                    self.stream.write(u"%s while reporting failure in %s\n" % \
+                                      (e.__class__.__name__, failure.location))
+                    self.stream.write(u"ERROR: %s\n" % \
+                                      _text(e, encoding=self.stream.encoding))
+                    unicode_errors += 1
+
+            if unicode_errors:
+                msg = u"HINT: %d unicode errors occured during failure reporting.\n"
+                self.stream.write(msg % unicode_errors)
+            self.stream.flush()