cucu 1.0.0__py3-none-any.whl

cucu/cli/run.py

@@ -0,0 +1,207 @@
+import contextlib
+import json
+import os
+import socket
+import sys
+from datetime import datetime
+
+from cucu import (
+    behave_tweaks,
+    init_global_hook_variables,
+    register_before_retry_hook,
+)
+from cucu.browser import selenium
+from cucu.config import CONFIG
+from cucu.page_checks import init_page_checks
+
+
+def get_feature_name(file_path):
+    with open(file_path, "r") as file:
+        text = file.read()
+        lines = text.split("\n")
+        for line in lines:
+            if "Feature:" in line:
+                feature_name = line.replace("Feature:", "").strip()
+                return feature_name
+
+
+def behave_init(filepath="features"):
+    """
+    behave internal init method used to load the various parts of set of
+    feature files and supporting code without executing any of it.
+
+    parameters:
+        filepath(string): the file system path of the features directory to load
+    """
+    behave_tweaks.behave_main(
+        ["--dry-run", "--format=null", "--no-summary", filepath]
+    )
+
+
+def behave(
+    filepath,
+    color_output,
+    dry_run,
+    env,
+    fail_fast,
+    headless,
+    name,
+    ipdb_on_failure,
+    junit,
+    results,
+    secrets,
+    show_skips,
+    tags,
+    verbose,
+    redirect_output=False,
+    skip_init_global_hook_variables=False,
+):
+    # load all them configs
+    CONFIG.load_cucurc_files(filepath)
+
+    if CONFIG["CUCU_SELENIUM_REMOTE_URL"] is None:
+        selenium.init()
+
+    # general socket timeout instead of letting the framework ever get stuck on a
+    # socket connect/read call
+    timeout = float(CONFIG["CUCU_SOCKET_DEFAULT_TIMEOUT_S"])
+    socket.setdefaulttimeout(timeout)
+
+    if not skip_init_global_hook_variables:
+        init_global_hook_variables()
+
+    init_page_checks()
+
+    os.environ["CUCU_COLOR_OUTPUT"] = str(color_output).lower()
+
+    if headless:
+        os.environ["CUCU_BROWSER_HEADLESS"] = "True"
+
+    for variable in list(env):
+        key, value = variable.split("=")
+        os.environ[key] = value
+
+    if ipdb_on_failure:
+        os.environ["CUCU_IPDB_ON_FAILURE"] = "true"
+
+    os.environ["CUCU_RESULTS_DIR"] = results
+    os.environ["CUCU_JUNIT_DIR"] = junit
+
+    if secrets:
+        os.environ["CUCU_SECRETS"] = secrets
+
+    args = [
+        # don't run disabled tests
+        "--tags",
+        "~@disabled",
+        # always print the skipped steps and scenarios
+        "--show-skipped",
+    ]
+
+    if verbose:
+        args.append("--verbose")
+
+    run_json_filename = "run.json"
+    if redirect_output:
+        feature_name = get_feature_name(filepath)
+        run_json_filename = f"{feature_name + '-run.json'}"
+
+    if dry_run:
+        args += [
+            "--dry-run",
+            # console formater
+            "--format=cucu.formatter.cucu:CucuFormatter",
+        ]
+
+    else:
+        args += [
+            "--no-capture",
+            "--no-capture-stderr",
+            "--no-logcapture",
+            # generate a JSON file containing the exact details of the whole run
+            "--format=cucu.formatter.json:CucuJSONFormatter",
+            f"--outfile={results}/{run_json_filename}",
+            # console formatter
+            "--format=cucu.formatter.cucu:CucuFormatter",
+            f"--logging-level={os.environ['CUCU_LOGGING_LEVEL'].upper()}",
+            # disable behave's junit output in favor of our own formatter
+            "--no-junit",
+            "--format=cucu.formatter.junit:CucuJUnitFormatter",
+        ]
+
+    for tag in tags:
+        args.append("--tags")
+        args.append(tag)
+
+    if name is not None:
+        args += ["--name", name]
+
+    if fail_fast:
+        args.append("--stop")
+
+    if not show_skips:
+        args.append("--no-skipped")
+
+    args.append(filepath)
+
+    result = 0
+    try:
+        if redirect_output:
+            feature_name = get_feature_name(filepath)
+            log_filename = f"{feature_name + '.log'}"
+            log_filepath = os.path.join(results, log_filename)
+
+            CONFIG["__CUCU_PARENT_STDOUT"] = sys.stdout
+
+            def retry_progress(ctx):
+                CONFIG["__CUCU_PARENT_STDOUT"].write(".")
+                CONFIG["__CUCU_PARENT_STDOUT"].flush()
+
+            # this allows steps that are stuck in a retry to loop to still
+            # provide progress feedback on screen
+            register_before_retry_hook(retry_progress)
+
+            with open(log_filepath, "w", encoding="utf8") as output:
+                with contextlib.redirect_stderr(output):
+                    with contextlib.redirect_stdout(output):
+                        # intercept the stdout/stderr so we can do things such
+                        # as hiding secrets in logs
+                        behave_tweaks.init_outputs(sys.stdout, sys.stderr)
+                        result = behave_tweaks.behave_main(args)
+        else:
+            # intercept the stdout/stderr so we can do things such
+            # as hiding secrets in logs
+            behave_tweaks.init_outputs(sys.stdout, sys.stderr)
+            result = behave_tweaks.behave_main(args)
+    except:
+        result = -1
+        raise
+
+    return result
+
+
+def write_run_details(results, filepath):
+    """
+    writes a JSON file with run details to the results directory which can be
+    used to figure out any runtime details that would otherwise be lost and
+    difficult to figure out.
+    """
+    run_details_filepath = os.path.join(results, "run_details.json")
+
+    if os.path.exists(run_details_filepath):
+        return
+
+    if CONFIG["CUCU_RECORD_ENV_VARS"]:
+        env_values = dict(os.environ)
+    else:
+        env_values = "To enable use the --record-env-vars flag"
+
+    run_details = {
+        "filepath": filepath,
+        "full_arguments": sys.argv,
+        "env": env_values,
+        "date": datetime.now().isoformat(),
+    }
+
+    with open(run_details_filepath, "w", encoding="utf8") as output:
+        output.write(json.dumps(run_details, indent=2, sort_keys=True))

cucu/cli/steps.py

@@ -0,0 +1,137 @@
+import contextlib
+import io
+import json
+import re
+
+from cucu import behave_tweaks
+
+
+def load_cucu_steps(filepath=None):
+    """
+    loads the cucu steps definition using behave and returns an array of
+    hashmaps that have the following structure:
+
+        {
+            [step_name]: {
+                "location": {
+                    "filepath": "...",
+                    "line": "...",
+                }
+            }
+        }
+
+    undefined steps are marked with a value of None instead of a location. ie:
+
+        {
+            [undefined_step_name]: None
+        }
+
+    Returns:
+        an array of hashmaps
+    """
+    steps_cache = {}
+    args = ["--dry-run", "--no-summary", "--format", "steps.doc"]
+
+    if filepath is not None:
+        args.append(filepath)
+
+    error = None
+
+    stdout = io.StringIO()
+    stderr = io.StringIO()
+
+    with contextlib.redirect_stderr(stderr):
+        with contextlib.redirect_stdout(stdout):
+            error = behave_tweaks.behave_main(args)
+
+    stdout = stdout.getvalue()
+    stderr = stderr.getvalue()
+
+    if stdout.startswith("ParserError"):
+        print(stdout)
+        raise RuntimeError(
+            "unable to parse feature files, see above for details"
+        )
+
+    for cucu_step in stdout.split("@step"):
+        # Each line of a step definition looks like so:
+        #
+        #   @step('I should see "{this}" matches "{that}"')
+        #     Function: inner_step()
+        #     Location: src/cucu/behave_tweaks.py:64
+        #      possibly a doc string here on the function that can be used
+        #      to add a little documentation to each step definition
+        #
+        #   @step('I should see "{this}" matches the following')
+        #     Function: inner_step()
+        #     Location: src/cucu/behave_tweaks.py:64
+        #
+        if cucu_step.strip() == "":
+            continue
+
+        if not cucu_step.startswith("("):
+            #
+            # any block of lines between the `@step` that doesn't start with the
+            # character ( is an error being reported behave when loading steps
+            # and we'll ignore it when processing the step definitions and then
+            # report the actual underlying trace reported in STDERR below
+            #
+            print("unable to parse some step lines")
+            continue
+
+        lines = cucu_step.split("\n")
+
+        #
+        # parts[1] is the function name while parts[3:] is the docstring
+        # of the step which we can use for documenting usage of the step
+        # in the language server
+        #
+        step_name = lines[0]
+        location = lines[2]
+
+        step_name = re.match(r"\('(.*)'\)", step_name).groups()[0]
+        _, filepath, line_number = location.split(":")
+
+        steps_cache[step_name] = {
+            "location": {
+                "filepath": filepath.strip(),
+                "line": line_number.strip(),
+            }
+        }
+
+    # collect any undefined steps
+    for line in stderr.split("\n"):
+        # @when(u'I close the current browser caca')
+        match = re.match(r"@[a-z]+\(u'([^']+)'\)", line)
+        if match:
+            step_name = match.group(1)
+            steps_cache[step_name] = None
+
+    if error == 0:
+        return (steps_cache, None)
+
+    else:
+        return (steps_cache, stderr)
+
+
+def print_json_steps(filepath=None):
+    """
+    pretty print the steps in a JSON fart
+    """
+    steps, steps_error = load_cucu_steps(filepath=filepath)
+    print(json.dumps(steps, indent=2, sort_keys=True))
+
+
+def print_human_readable_steps(filepath=None):
+    steps, steps_error = load_cucu_steps(filepath=filepath)
+
+    for step_name in steps:
+        if steps[step_name] is not None:
+            if filepath in steps[step_name]["location"]["filepath"]:
+                print(f"custom: {step_name}")
+            else:
+                print(f"cucu:   {step_name}")
+
+    if steps_error is not None:
+        print(steps_error)
+        raise RuntimeError("Failure loading some steps, see above for details")

cucu/cli/thread_dumper.py

@@ -0,0 +1,55 @@
+import sys
+import threading
+import traceback
+
+
+class ThreadDumper(threading.Thread):
+    """
+    thread dumping class that can be easily stopped by calling the `.stop()`
+    method.
+    """
+
+    def __init__(self, interval_min, stdout, *args, **kwargs):
+        super(ThreadDumper, self).__init__(*args, **kwargs)
+        self.interval_min = interval_min
+        self.stdout = stdout
+        self.running = False
+        self.event = threading.Event()
+
+    def stop(self):
+        self.running = False
+        self.event.set()
+
+    def start(self):
+        self.running = True
+        super().start()
+
+    def run(self):
+        while self.running:
+            self.stdout.write(f"\n{'*' * 80}\n")
+            for thread in threading.enumerate():
+                self.stdout.write(f"{thread}\n")
+                traceback.print_stack(
+                    sys._current_frames()[thread.ident], file=self.stdout
+                )
+                self.stdout.write("\n")
+            self.stdout.write(f"{'*' * 80}\n")
+            self.event.wait(self.interval_min * 60)
+
+
+def start(interval_min):
+    """
+    start the thread dumper and return it so one can call the `.stop()` method
+    on it to get it to quit
+
+    parameters:
+        interval_min(float): number of minutes between each thread stacktrace
+                             dump to print
+
+    returns:
+        a ThreadDumper object that is a child of the threading.Thread class with
+        the method `.stop()` to get the thread to quit
+    """
+    thread = ThreadDumper(interval_min, sys.stdout)
+    thread.start()
+    return thread