cucu 1.0.0__py3-none-any.whl

cucu/formatter/cucu.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import traceback
+
+from behave.formatter.ansi_escapes import colors, escapes, up
+from behave.formatter.base import Formatter
+from behave.model_core import Status
+from behave.model_describe import ModelPrinter
+from behave.textutil import make_indentation
+
+from cucu.config import CONFIG
+
+
+class CucuFormatter(Formatter):
+    """ """
+
+    name = "cucu"
+    description = "cucu specific formatter to make the logs more readable"
+
+    DEFAULT_INDENT_SIZE = 2
+    SUBSTEP_PREFIX = "  ⤷"
+
+    def __init__(self, stream_opener, config, **kwargs):
+        super(CucuFormatter, self).__init__(stream_opener, config)
+        self.current_scenario = None
+        self.steps = []
+        self.match_step_index = 0
+        self.show_timings = config.show_timings
+        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
+
+        color_output = CONFIG["CUCU_COLOR_OUTPUT"]
+        self.monochrome = color_output != "true"
+
+    @property
+    def multiline_indentation(self):
+        if self._multiline_indentation is None:
+            # align keywords
+            offset = 2
+            indentation = make_indentation(3 * self.indent_size + offset)
+            self._multiline_indentation = indentation
+
+        return self._multiline_indentation
+
+    def write_tags(self, tags, indent=None, for_feature=False):
+        """
+        writes the tags for a scenario or feature and takes extra care to be
+        sure to indent corectly for scenarios when `indent` is specified. We
+        also handle putting new lines in the right locations if its a scenario
+        or feature based on `for_feature` boolean flag.
+        """
+        indent = indent or ""
+        if tags:
+            text = " @".join(tags)
+            line = self.colorize(f"{indent}@{text}", "cyan")
+            if for_feature:
+                self.stream.write(f"{line}\n")
+            else:
+                self.stream.write(f"\n{line}")
+
+    # -- IMPLEMENT-INTERFACE FOR: Formatter
+    def feature(self, feature):
+        self.write_tags(feature.tags, for_feature=True)
+        text = f'{self.colorize(feature.keyword, "magenta")}: {feature.name}\n'
+        self.stream.write(text)
+
+    def colorize(self, text, color):
+        if self.monochrome:
+            return text
+        else:
+            return colors[color] + text + escapes["reset"]
+
+    def background(self, background):
+        if not self.monochrome:
+            indent = make_indentation(self.indent_size)
+            keyword = self.colorize(background.keyword, "magenta")
+            text = f"\n{indent}{keyword}: {background.name}\n"
+            self.stream.write(text)
+
+    def scenario(self, scenario):
+        self.current_scenario = scenario
+
+        indent = make_indentation(self.indent_size)
+        text = "\n%s%s: %s\n" % (
+            indent,
+            self.colorize(scenario.keyword, "magenta"),
+            scenario.name,
+        )
+        self.write_tags(scenario.tags, indent)
+        self.stream.write(text)
+        self.steps = []
+        self.match_step_index = 0
+
+    def step(self, step):
+        self.insert_step(step)
+
+    def insert_step(self, step, index=-1):
+        # used to determine how to better handle console output
+        step.has_substeps = False
+        step.is_substep = False
+
+        if index == -1:
+            self.steps.append(step)
+        else:
+            self.steps.insert(index, step)
+
+    def match(self, match):
+        if self.monochrome:
+            return
+
+        # we'll write a step line in grey and not hit the carriage return
+        step = self.steps[self.match_step_index]
+        self.match_step_index += 1
+
+        indent = make_indentation(2 * self.indent_size)
+        keyword = step.keyword.rjust(5)
+
+        prefix = ""
+        if step.is_substep:
+            prefix = self.SUBSTEP_PREFIX
+
+        text = self.colorize(
+            f"{indent}{prefix}{keyword} {step.name}\n", "grey"
+        )
+        self.stream.write(text)
+        self.stream.flush()
+
+    def calculate_max_line_length(self):
+        line_lengths = [
+            len(f"{step.keyword.rjust(5)} {step.name}") for step in self.steps
+        ]
+
+        return max(line_lengths) + 4
+
+    def result(self, step):
+        indent = make_indentation(2 * self.indent_size)
+        keyword = step.keyword.rjust(5)
+
+        if not (
+            self.monochrome
+            or step.has_substeps
+            or CONFIG["__CUCU_WROTE_TO_OUTPUT"]
+        ):
+            self.stream.write(up(1))
+
+        prefix = ""
+        if step.is_substep:
+            prefix = self.SUBSTEP_PREFIX
+
+        if step.status == Status.passed:
+            keyword = self.colorize(keyword, "green")
+            text = f"{indent}{prefix}{keyword} {step.name}"
+        elif step.status == Status.failed:
+            text = self.colorize(
+                f"{indent}{prefix}{keyword} {step.name}", "red"
+            )
+        elif step.status == Status.undefined:
+            text = self.colorize(
+                f"{indent}{prefix}{keyword} {step.name}", "yellow"
+            )
+        elif step.status == Status.skipped:
+            text = self.colorize(
+                f"{indent}{prefix}{keyword} {step.name}\n", "cyan"
+            )
+        elif step.status == Status.untested:
+            text = self.colorize(
+                f"{indent}{prefix}{keyword} {step.name}\n", "cyan"
+            )
+
+        if self.monochrome:
+            self.stream.write(f"{text}")
+        else:
+            self.stream.write(f"\r{text}")
+
+        if step.status in (Status.passed, Status.failed):
+            max_line_length = self.calculate_max_line_length()
+            status_text = ""
+            if self.show_timings:
+                start = step.start_timestamp
+                duration = f"{step.duration:.3f}"
+                status_text += f" # started at {start} took {duration}s"
+
+            current_step_text = f"{step.keyword.rjust(5)} {step.name}"
+            status_text_padding = (
+                max_line_length - len(current_step_text) - len(prefix)
+            )
+            status_text = f'{" " * status_text_padding}{status_text}'
+            status_text = self.colorize(status_text, "yellow")
+
+            self.stream.write(f"{status_text}\n")
+            if step.error_message:
+                self.stream.write(f"{step.error_message}\n")
+
+        if step.text:
+            self.doc_string(step.text)
+
+        if step.table:
+            self.table(getattr(step.table, "original", step.table))
+
+        if step.status in (Status.passed, Status.failed):
+            # print the variable values in step name, multiline/table arguments
+            # as a comment to ease debugging
+            step_variables = CONFIG.expand(step.name)
+
+            if step.text:
+                step_variables.update(CONFIG.expand(step.text))
+
+            if step.table:
+                for row in step.table.original.rows:
+                    for value in row:
+                        step_variables.update(CONFIG.expand(value))
+
+            if step_variables:
+                expanded = " ".join(
+                    [
+                        f'{key}="{value}"'
+                        for (key, value) in step_variables.items()
+                    ]
+                )
+
+                padding = f"    {' '*(len('Given')-len(step.keyword))}"
+                variable_line = f"{padding}# {expanded}\n"
+                # hide secrets before we do anything to add color which could
+                # modify the output and result in not being able to correctly
+                # parse
+                # TODO: I'd like to move this out of here as we should be able
+                #       to intercept all of the stdout/stderr writes but seems
+                #       behaves underlying self.stream here is getting around
+                #       that by accessing stdout/stderr another way.
+                variable_line = CONFIG.hide_secrets(variable_line)
+                colored_variable_line = self.colorize(variable_line, "blue")
+                self.stream.write(colored_variable_line)
+                self.stream.flush()
+
+        self.previous_step = step
+        CONFIG["__CUCU_WROTE_TO_OUTPUT"] = False
+
+    def eof(self):
+        self.stream.write("\n")
+
+        if self.current_scenario:
+            if self.current_scenario.status.name == "failed":
+                # we need to record the error_message and exc_traceback in the
+                # last executed step and mark it as failed so the reporting can
+                # show the result correctly
+                error_message = traceback.format_tb(
+                    self.current_scenario.exc_traceback
+                )
+                self.stream.write("\n".join(error_message))
+
+    # -- 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)

cucu/formatter/json.py

@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+#
+# adapted from:
+#   https://github.com/behave/behave/blob/master/behave/formatter/json.py
+#
+from __future__ import absolute_import
+
+import json
+import traceback
+import uuid
+
+import six
+from behave.formatter.base import Formatter
+from behave.model_core import Status
+from tenacity import RetryError
+
+from cucu.config import CONFIG
+
+
+# -----------------------------------------------------------------------------
+# CLASS: JSONFormatter
+# -----------------------------------------------------------------------------
+class CucuJSONFormatter(Formatter):
+    name = "cucu-json"
+    description = "JSON dump of test run"
+    dumps_kwargs = {"indent": 2, "sort_keys": True}
+
+    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(CucuJSONFormatter, 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.last_step = None
+        self.steps = []
+        self.write_json_header()
+
+    def reset(self):
+        self.current_feature = None
+        self.current_feature_data = None
+        self.current_scenario = None
+
+    # -- 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
+
+        # -- 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,
+            }
+        )
+        self.steps = []
+        if scenario.description:
+            element["description"] = scenario.description
+
+    @classmethod
+    def make_table(cls, table):
+        table_data = {
+            "headings": table.headings,
+            "rows": [list(row) for row in table.rows],
+        }
+        return table_data
+
+    def insert_step(self, step, index=-1):
+        step.unique_id = uuid.uuid1()
+        is_substep = getattr(step, "is_substep", False)
+
+        step_details = {
+            "keyword": step.keyword,
+            "step_type": step.step_type,
+            "name": step.name,
+            "location": six.text_type(step.location),
+            "substep": is_substep,
+        }
+
+        if step.text:
+            text = step.text
+            if self.split_text_into_lines and "\n" in text:
+                text = text.splitlines()
+            step_details["text"] = text
+        if step.table:
+            step_details["table"] = self.make_table(step.table)
+        element = self.current_feature_element
+
+        if index == -1:
+            self.steps.append(step)
+            element["steps"].append(step_details)
+        else:
+            self.steps.insert(index, step)
+            element["steps"].insert(index, step_details)
+
+    def step(self, step):
+        self.insert_step(step, index=-1)
+
+    def match(self, match):
+        # nothing to do, but we need to implement the method
+        pass
+
+    def result(self, step):
+        steps = self.current_feature_element["steps"]
+        step_index = 0
+        for other_step in self.steps:
+            if other_step.unique_id == step.unique_id:
+                break
+            step_index += 1
+
+        # keep the last step recorded result state
+        self.last_step = steps[step_index]
+
+        timestamp = None
+        if step.status.name in ["passed", "failed"]:
+            timestamp = step.start_timestamp
+
+            step_variables = CONFIG.expand(step.name)
+
+            if step.text:
+                step_variables.update(CONFIG.expand(step.text))
+
+            if step.table:
+                for row in step.table.original.rows:
+                    for value in row:
+                        step_variables.update(CONFIG.expand(value))
+
+            if step_variables:
+                expanded = " ".join(
+                    [
+                        f'{key}="{value}"'
+                        for (key, value) in step_variables.items()
+                    ]
+                )
+                padding = f"    {' '*(len('Given')-len(step.keyword))}"
+                step.stdout.insert(
+                    0, f"{padding}# {CONFIG.hide_secrets(expanded)}\n"
+                )
+
+        stdout = None
+        if "stdout" in step.__dict__ and step.stdout != []:
+            stdout = [CONFIG.hide_secrets("".join(step.stdout).rstrip())]
+
+        stderr = None
+        if "stderr" in step.__dict__ and step.stderr != []:
+            stderr = [CONFIG.hide_secrets("".join(step.stderr).rstrip())]
+
+        steps[step_index]["result"] = {
+            "stdout": stdout,
+            "stderr": stderr,
+            "status": step.status.name,
+            "duration": step.duration,
+            "timestamp": timestamp,
+        }
+
+        if step.error_message and step.status == Status.failed:
+            # -- OPTIONAL: Provided for failed steps.
+            error_message = CONFIG.hide_secrets(step.error_message)
+            if self.split_text_into_lines:
+                error_message = error_message.splitlines()
+
+            result_element = steps[step_index]["result"]
+            result_element["error_message"] = error_message
+
+            if error := step.exception:
+                if isinstance(error, RetryError):
+                    error = error.last_attempt.exception()
+
+                if len(error.args) > 0 and isinstance(error.args[0], str):
+                    error_class_name = error.__class__.__name__
+                    redacted_error_msg = CONFIG.hide_secrets(error.args[0])
+                    error_lines = redacted_error_msg.splitlines()
+                    error_lines[0] = f"{error_class_name}: {error_lines[0]}"
+                else:
+                    error_lines = [repr(error)]
+
+                result_element["exception"] = error_lines
+
+    def embedding(self, mime_type, data):
+        # nothing to do, but we need to implement the method
+        pass
+
+    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()
+
+        self.write_json_feature(self.current_feature_data)
+        self.reset()
+
+    def close(self):
+        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:
+            hook_failed = self.current_scenario.hook_failed
+            if hook_failed:
+                status_name = "errored"
+            else:
+                status_name = self.current_scenario.status.name
+
+            self.current_feature_element["status"] = status_name
+
+            if status_name in ["failed", "errored"]:
+                # we need to record the error_message and exc_traceback in the
+                # last executed step and mark it as failed so the reporting can
+                # show the result correctly
+                error_message = [self.current_scenario.error_message]
+                error_message += traceback.format_tb(
+                    self.current_scenario.exc_traceback
+                )
+                #  If a before scenario hook fails, last_step will be None.
+                if (
+                    self.last_step is not None
+                    and "error_message" not in self.last_step["result"]
+                ):
+                    self.last_step["result"]["error_message"] = error_message
+
+    # -- 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):
+        if "elements" not in feature_data:
+            return
+
+        filtered_scenarios = [
+            x
+            for x in feature_data["elements"]
+            if x["keyword"] == "Scenario"
+            and (
+                CONFIG["CUCU_SHOW_SKIPS"] == "true" or x["status"] != "skipped"
+            )
+        ]
+
+        if len(filtered_scenarios) == 0:
+            return
+
+        feature_data["elements"] = filtered_scenarios
+
+        if self.feature_count != 0:
+            self.write_json_feature_separator()
+
+        self.stream.write(json.dumps(feature_data, **self.dumps_kwargs))
+        self.stream.flush()
+        self.feature_count += 1
+
+    def write_json_feature_separator(self):
+        self.stream.write(",\n\n")