PyPI - cucu - Versions diffs - 1.0.0__py3-none-any.whl - Mend

cucu 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of cucu might be problematic. Click here for more details.

Files changed (83) hide show

cucu/__init__.py +38 -0
cucu/ansi_parser.py +58 -0
cucu/behave_tweaks.py +196 -0
cucu/browser/__init__.py +0 -0
cucu/browser/core.py +80 -0
cucu/browser/frames.py +106 -0
cucu/browser/selenium.py +323 -0
cucu/browser/selenium_tweaks.py +27 -0
cucu/cli/__init__.py +3 -0
cucu/cli/core.py +788 -0
cucu/cli/run.py +207 -0
cucu/cli/steps.py +137 -0
cucu/cli/thread_dumper.py +55 -0
cucu/config.py +440 -0
cucu/edgedriver_autoinstaller/README.md +1 -0
cucu/edgedriver_autoinstaller/__init__.py +37 -0
cucu/edgedriver_autoinstaller/utils.py +231 -0
cucu/environment.py +283 -0
cucu/external/jquery/jquery-3.5.1.min.js +2 -0
cucu/formatter/__init__.py +0 -0
cucu/formatter/cucu.py +261 -0
cucu/formatter/json.py +321 -0
cucu/formatter/junit.py +289 -0
cucu/fuzzy/__init__.py +3 -0
cucu/fuzzy/core.py +107 -0
cucu/fuzzy/fuzzy.js +253 -0
cucu/helpers.py +875 -0
cucu/hooks.py +205 -0
cucu/language_server/__init__.py +3 -0
cucu/language_server/core.py +114 -0
cucu/lint/__init__.py +0 -0
cucu/lint/linter.py +397 -0
cucu/lint/rules/format.yaml +125 -0
cucu/logger.py +113 -0
cucu/matcher/__init__.py +0 -0
cucu/matcher/core.py +30 -0
cucu/page_checks.py +63 -0
cucu/reporter/__init__.py +3 -0
cucu/reporter/external/bootstrap.min.css +7 -0
cucu/reporter/external/bootstrap.min.js +7 -0
cucu/reporter/external/dataTables.bootstrap.min.css +1 -0
cucu/reporter/external/dataTables.bootstrap.min.js +14 -0
cucu/reporter/external/jquery-3.5.1.min.js +2 -0
cucu/reporter/external/jquery.dataTables.min.js +192 -0
cucu/reporter/external/popper.min.js +5 -0
cucu/reporter/favicon.png +0 -0
cucu/reporter/html.py +452 -0
cucu/reporter/templates/feature.html +72 -0
cucu/reporter/templates/flat.html +48 -0
cucu/reporter/templates/index.html +49 -0
cucu/reporter/templates/layout.html +109 -0
cucu/reporter/templates/scenario.html +200 -0
cucu/steps/__init__.py +27 -0
cucu/steps/base_steps.py +88 -0
cucu/steps/browser_steps.py +337 -0
cucu/steps/button_steps.py +91 -0
cucu/steps/checkbox_steps.py +111 -0
cucu/steps/command_steps.py +181 -0
cucu/steps/comment_steps.py +17 -0
cucu/steps/draggable_steps.py +168 -0
cucu/steps/dropdown_steps.py +467 -0
cucu/steps/file_input_steps.py +80 -0
cucu/steps/filesystem_steps.py +144 -0
cucu/steps/flow_control_steps.py +198 -0
cucu/steps/image_steps.py +37 -0
cucu/steps/input_steps.py +301 -0
cucu/steps/link_steps.py +63 -0
cucu/steps/menuitem_steps.py +39 -0
cucu/steps/platform_steps.py +29 -0
cucu/steps/radio_steps.py +187 -0
cucu/steps/step_utils.py +55 -0
cucu/steps/tab_steps.py +68 -0
cucu/steps/table_steps.py +437 -0
cucu/steps/tables.js +28 -0
cucu/steps/text_steps.py +78 -0
cucu/steps/variable_steps.py +100 -0
cucu/steps/webserver_steps.py +40 -0
cucu/utils.py +269 -0
cucu-1.0.0.dist-info/METADATA +424 -0
cucu-1.0.0.dist-info/RECORD +83 -0
cucu-1.0.0.dist-info/WHEEL +4 -0
cucu-1.0.0.dist-info/entry_points.txt +2 -0
cucu-1.0.0.dist-info/licenses/LICENSE +32 -0

cucu/__init__.py ADDED Viewed

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+__version__ = "0.1.0"
+import sys
+from cucu import behave_tweaks
+from cucu.browser import selenium_tweaks
+# intercept the stdout/stderr so we can do things such as hiding secrets in logs
+behave_tweaks.init_step_hooks(sys.stdout, sys.stderr)
+selenium_tweaks.init()
+from cucu.hooks import (
+    init_global_hook_variables,
+    init_scenario_hook_variables,
+    register_after_all_hook,
+    register_before_all_hook,
+    register_after_this_scenario_hook,
+    register_before_scenario_hook,
+    register_after_scenario_hook,
+    register_before_step_hook,
+    register_after_step_hook,
+    register_page_check_hook,
+    register_custom_variable_handling,
+    register_custom_tags_in_report_handling,
+    register_custom_scenario_subheader_in_report_handling,
+    register_custom_junit_failure_handler,
+    register_before_retry_hook,
+)
+from cucu.utils import (
+    format_gherkin_table,
+    run_steps,
+    retry,
+    StopRetryException,
+)
+from cucu import helpers
+from behave import step

cucu/ansi_parser.py ADDED Viewed

@@ -0,0 +1,58 @@
+import html
+import re
+from behave.formatter.ansi_escapes import colors, escapes
+ESC_SEQ = r"\x1b["
+TRANSLATION = (
+    {colors["grey"]: '<span style="color: grey;">\n'}
+    | {  # grey indicates a new step, and hence add a line break
+        v: f'<span style="color: {k};">'
+        for k, v in colors.items()
+        if k != "grey"
+    }
+    | {
+        "\n" + escapes["reset"] + "\n": "</span>\n",
+        escapes["reset"]: "</span>",
+        escapes["up"] + "\n": "",  # remove a line break with cursor up
+        ESC_SEQ + "46": "",  # ignore DELETE (num keypad)
+        ESC_SEQ + "48": "",  # ignore INSERT (num keypad)
+        ESC_SEQ + "49": "",  # ignore END (num keypad)
+        ESC_SEQ + "50": "",  # ignore DOWN ARROW (num keypad)
+        ESC_SEQ + "51": "",  # ignore PAGE DOWN (num keypad)
+        ESC_SEQ + "52": "",  # ignore LEFT ARROW (num keypad)
+        ESC_SEQ + "54": "",  # ignore RIGHT ARROW (num keypad)
+        ESC_SEQ + "55": "",  # ignore HOME (num keypad)
+        ESC_SEQ + "56": "",  # ignore UP ARROW (num keypad)
+        ESC_SEQ + "57": "",  # ignore PAGE UP (num keypad)
+    }
+)
+RE_TO_HTML = re.compile("|".join(map(re.escape, TRANSLATION)))
+RE_TO_REMOVE = re.compile(
+    r"\x1b\[(0;)?[0-9A-F]{1,2}m"
+)  # detect hex values, not just decimal digits
+def remove_ansi(input: str) -> str:
+    return RE_TO_REMOVE.sub("", input)
+def parse_log_to_html(input: str) -> str:
+    """
+    Parse an ansi color log to html
+    """
+    html_start = "<!DOCTYPE html>\n<html>\n"
+    html_end = "</html>\n"
+    head = '<head>\n<meta http-equiv="Content-Type" content="text/html; charset=utf-8">\n</head>\n'
+    body_start = '<body style="color: white; background-color: #100c08;">'  # use dark bg since colors are from behave
+    body_end = "</body>\n"
+    result = f"{html_start}{head}{body_start}<pre>\n{RE_TO_HTML.sub(lambda match: TRANSLATION[match.group(0)], html.escape(input, quote=False))}\n</pre>{body_end}{html_end}"
+    if ESC_SEQ in result:
+        lines = "\n".join([x for x in result.split("\n") if ESC_SEQ in x])
+        print(
+            f"Detected unmapped ansi escape code!:\n{lines}"
+        )  # use print instead of logger to avoid circular import
+    return result

cucu/behave_tweaks.py ADDED Viewed

@@ -0,0 +1,196 @@
+#
+# XXX: a lot of convoluted logic to handle capturing per step stdou/stderr
+#      writing while not interfering with the way behave does its own log
+#      capturing
+#
+import sys
+import warnings
+from functools import wraps
+import behave
+from behave.__main__ import main as original_behave_main
+from behave.model import Table
+from cucu.config import CONFIG
+def behave_main(args):
+    return original_behave_main(args)
+def init_outputs(stdout, stderr):
+    # capturing stdout and stderr output to record in reporting
+    sys.stdout = CucuOutputStream(sys.stdout)
+    sys.stderr = CucuOutputStream(sys.stderr)
+def init_step_hooks(stdout, stderr):
+    init_outputs(stdout, stderr)
+    #
+    # wrap the given, when, then, step decorators from behave so we can intercept
+    # the step arguments and do things such as replacing variable references that
+    # are wrapped with curly braces {...}.
+    #
+    for decorator_name in ["given", "when", "then", "step"]:
+        decorator = behave.__dict__[decorator_name]
+        def inner_step_func(func, *args, variable_passthru=False, **kwargs):
+            #
+            # replace the variable references in the args and kwargs passed to the
+            # step
+            #
+            # TODO: for tables and multiline strings there's a bit more
+            #       work to be done here.
+            #
+            if not variable_passthru:
+                args = [CONFIG.resolve(value) for value in args]
+                kwargs = {
+                    key: CONFIG.resolve(val) for (key, val) in kwargs.items()
+                }
+                # resolve variables in text and table data
+                ctx = args[0]
+                # we know what we're doing modifying this ctx value and so lets
+                # avoid the unnecessary warning int he logs
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore")
+                    # resolve variables in the multiline string arguments
+                    ctx.text = CONFIG.resolve(ctx.text)
+                    # resolve variables in the table values
+                    if ctx.table is not None:
+                        ctx.table.original = Table(
+                            ctx.table.headings, rows=ctx.table.rows
+                        )
+                        new_rows = []
+                        for row in ctx.table.rows:
+                            new_row = []
+                            for value in row:
+                                new_row.append(CONFIG.resolve(value))
+                            new_rows.append(new_row)
+                        ctx.table.rows = new_rows
+            func(*args, **kwargs)
+        def new_decorator(
+            step_text, fix_inner_step=lambda x: x, variable_passthru=False
+        ):
+            """
+            the new @step decorator
+            parameters:
+              step_text(string): the actual step string definition.
+              fix_inner_step(function): a function used to fix the inner_step
+                                        function code location and other
+                                        properties.
+              variable_passthru(bool): when set to true the variables are not
+                                       replaced in the arguments of the step
+                                       text and so variable references such as
+                                       {FOO} are passed as such so they can
+                                       be handled further down in `run_steps`
+                                       for example.
+            """
+            #
+            # IMPORTANT: if you add any additional line from the `wrapper`
+            #            function name to the `inner_step` name then you HAVE to
+            #            update the `src/cucu/helpers.py` fix_inner_step
+            #            so it subtracts the lines between wrapper and
+            #            inner_step functions (lines of code). More details
+            #            at the `src/cucu/helpers.py` location.
+            #
+            def wrapper(func):
+                @decorator(step_text)
+                @wraps(func)
+                def inner_step(*args, **kwargs):
+                    inner_step_func(
+                        func,
+                        *args,
+                        variable_passthru=variable_passthru,
+                        **kwargs,
+                    )
+                fix_inner_step(inner_step)
+            return wrapper
+        behave.__dict__[decorator_name] = new_decorator
+_stdout = sys.stdout
+class CucuOutputStream:
+    """
+    encapsulates a lot of the logic to handle capturing step by step console
+    logging but also redirecting logging at runtime to another stream
+    FYI: in order to print to the screen you must use directly the sys.stdout object
+         and write to it here as doing something like `print(...)` will result
+         in an infinite recursive loop and break
+    """
+    def __init__(self, stream, other_stream=None):
+        self.captured_data = []
+        self.stream = stream
+        self.encoding = stream.encoding
+        self.other_stream = other_stream
+    def set_other_stream(self, other):
+        self.other_stream = other
+    def __getattr__(self, item):
+        return self.stream.__getattribute__(item)
+    def isatty(self, *args, **kwargs):
+        return self.stream.isatty(*args, **kwargs)
+    def fileno(self):
+        return self.stream.fileno()
+    def flush(self):
+        self.stream.flush()
+        if self.other_stream:
+            self.other_stream.flush()
+    def write(self, byte):
+        byte = CONFIG.hide_secrets(byte)
+        self.captured_data.append(byte)
+        if isinstance(byte, bytes):
+            self.stream.write(byte.decode("utf8"))
+            if self.other_stream:
+                self.other_stream.write(byte.decode("utf8"))
+        else:
+            self.stream.write(byte)
+            if self.other_stream:
+                self.other_stream.write(byte)
+    def writelines(self, lines):
+        lines = [CONFIG.hide_secrets(line) for line in lines]
+        for line in lines:
+            self.captured_data.append(line)
+        self.stream.writelines(lines)
+        if self.other_stream:
+            self.other_stream.writelines(lines)
+    def captured(self):
+        """
+        returns the data captured thus far to the stream and resets the internal
+        buffer to empty.
+        """
+        captured_data = self.captured_data
+        self.captured_data = []
+        return captured_data

cucu/browser/__init__.py ADDED Viewed

File without changes

cucu/browser/core.py ADDED Viewed

@@ -0,0 +1,80 @@
+#
+# cucu's browser implementatoin is an abstraction to allow us to easily
+# run the same tests against a browser being managed by selenium, cypress or
+# any other future browser testing framework
+#
+import time
+from cucu import logger
+from cucu.config import CONFIG
+class Browser:
+    def __init__(self):
+        pass
+    def open(self, *args, **kwargs):
+        raise RuntimeError("implement me")
+    def navigate(self, url):
+        raise RuntimeError("implement me")
+    def switch_to_next_tab(self):
+        raise RuntimeError("implement me")
+    def switch_to_previous_tab(self):
+        raise RuntimeError("implement me")
+    def back(self):
+        raise RuntimeError("implement me")
+    def refresh(self):
+        raise RuntimeError("implement me")
+    def get_current_url(self):
+        raise RuntimeError("implement me")
+    def title(self):
+        raise RuntimeError("implement me")
+    def execute(self, javascript, *args, **kwargs):
+        raise RuntimeError("implement me")
+    def click(self, element):
+        raise RuntimeError("implement me")
+    def switch_to_default_frame(self):
+        raise RuntimeError("implement me")
+    def switch_to_frame(self, frame):
+        raise RuntimeError("implement me")
+    def screenshot(self, filepath):
+        raise RuntimeError("implement me")
+    def close_window(self):
+        raise RuntimeError("implement me")
+    def quit(self):
+        raise RuntimeError("implement me")
+    # built in methods to be used by all browser implementations
+    def wait_for_page_to_load(self):
+        """
+        this method is to be used by all browser implementations and called
+        when after clicking something or refreshing the page and we'd like to
+        make sure the is "loaded" and ready to be interacted with.
+        this also gives us a place to fire off any additional page checks such
+        as a console log checker, broken image checker, etc.
+        """
+        # run the page checks
+        if CONFIG["__CUCU_PAGE_CHECK_HOOKS"]:
+            for name, hook in CONFIG["__CUCU_PAGE_CHECK_HOOKS"].items():
+                logger.debug(f'executing page check "{name}"')
+                start = time.time()
+                hook(self)
+                logger.debug(
+                    f'executed page check "{name}" in {round(time.time()-start, 3)}s'
+                )

cucu/browser/frames.py ADDED Viewed

@@ -0,0 +1,106 @@
+from cucu.browser.core import Browser
+def search_in_all_frames(browser, search_function):
+    """
+    search all frames on the page for an element
+    Warning: This leaves the browser in whatever frame was last searched so that
+    users of this method are in that frame.
+    parameters:
+      browser           - the cucu.browser.Browser object
+      search_function   - function to search for the element (within a frame)
+    returns:
+        the WebElement that matches (if found)
+    """
+    # check whatever frame we're currently in
+    result = search_function()
+    if not result:
+        # we might have not been in the default frame so check again
+        browser.switch_to_default_frame()
+        result = search_function()
+        if result:
+            return result
+        frames = browser.execute('return document.querySelectorAll("iframe");')
+        for frame in frames:
+            # need to be in the default frame in order to switch to a child
+            # frame w/o getting a stale element exception
+            browser.switch_to_default_frame()
+            browser.switch_to_frame(frame)
+            result = search_function()
+            if result:
+                return result
+    return result
+def run_in_all_frames(browser, search_function):
+    """
+    run the search function on all of the available frames and return the
+    appending of all the arrays.
+    Warning: This leaves the browser in whatever frame was last searched so that
+    users of this method are in that frame.
+    parameters:
+      browser           - the cucu.browser.Browser object
+      search_function   - function that returns an array of WebElements
+    returns:
+        the array of all of the WebElements found.
+    """
+    result = []
+    browser.switch_to_default_frame()
+    result += search_function()
+    frames = browser.execute('return document.querySelectorAll("iframe");')
+    for frame in frames:
+        # need to be in the default frame in order to switch to a child
+        # frame w/o getting a stale element exception
+        browser.switch_to_default_frame()
+        browser.switch_to_frame(frame)
+        result += search_function()
+    return result
+def try_in_frames_until_success(browser: Browser, function_to_run) -> None:
+    """
+    Run the function on all of the possible frames one by one. It terminates
+    if the function doesn't raise an exception on a frame.
+    Warning: This leaves the browser in whatever frame the function is run successfully
+    so that users of the this method are in that frame.
+    Args:
+        browser (Browser): the browser session
+        function_to_run : a function that raises an exception if it fails
+    Raises:
+        RuntimeError: when the function fails in all frames
+    """
+    browser.switch_to_default_frame()
+    try:
+        function_to_run()
+    except Exception:
+        frames = browser.execute('return document.querySelectorAll("iframe");')
+        for frame in frames:
+            # need to be in the default frame in order to switch to a child
+            # frame w/o getting a stale element exception
+            browser.switch_to_default_frame()
+            browser.switch_to_frame(frame)
+            try:
+                function_to_run()
+            except Exception:
+                if frames.index(frame) < len(frames) - 1:
+                    continue
+                else:
+                    raise RuntimeError(
+                        f"{function_to_run.__name__} failed in all frames"
+                    )
+            return