cucu 1.0.0__py3-none-any.whl

cucu/hooks.py

@@ -0,0 +1,205 @@
+import re
+from collections import OrderedDict
+
+from cucu.config import CONFIG
+
+CONFIG.define(
+    "CUCU_BROKEN_IMAGES_PAGE_CHECK",
+    "enable/disable the broken image page checker",
+    default="enabled",
+)
+CONFIG.define(
+    "CUCU_READY_STATE_PAGE_CHECK",
+    "enable/disable the ready state page checker",
+    default="enabled",
+)
+
+
+def init_global_hook_variables():
+    CONFIG["__CUCU_BEFORE_ALL_HOOKS"] = []
+    CONFIG["__CUCU_AFTER_ALL_HOOKS"] = []
+
+    CONFIG["__CUCU_BEFORE_SCENARIO_HOOKS"] = []
+    CONFIG["__CUCU_AFTER_SCENARIO_HOOKS"] = []
+
+    CONFIG["__CUCU_BEFORE_STEP_HOOKS"] = []
+    CONFIG["__CUCU_AFTER_STEP_HOOKS"] = []
+
+    CONFIG["__CUCU_PAGE_CHECK_HOOKS"] = OrderedDict()
+    CONFIG["__CUCU_HTML_REPORT_TAG_HANDLERS"] = {}
+    CONFIG["__CUCU_HTML_REPORT_SCENARIO_SUBHEADER_HANDLER"] = []
+
+    CONFIG["__CUCU_CUSTOM_FAILURE_HANDLERS"] = []
+    CONFIG["__CUCU_BEFORE_RETRY_HOOKS"] = []
+    CONFIG["__CUCU_CTX"] = None
+
+
+def init_scenario_hook_variables():
+    CONFIG["__CUCU_BEFORE_THIS_SCENARIO_HOOKS"] = []
+    CONFIG["__CUCU_AFTER_THIS_SCENARIO_HOOKS"] = []
+
+
+def register_before_all_hook(hook_func):
+    """
+    register a before all hook that will execute once before anything is
+    executed and we will pass the current behave context object as the only
+    argument to the hook_func provided.
+    """
+    CONFIG["__CUCU_BEFORE_ALL_HOOKS"].append(hook_func)
+
+
+def register_after_all_hook(hook_func):
+    """
+    register an after all hook that will execute once after everything is
+    executed and we will pass the current behave context object as the only
+    argument to the hook_func provided.
+    """
+    CONFIG["__CUCU_AFTER_ALL_HOOKS"].append(hook_func)
+
+
+def register_before_scenario_hook(hook_func):
+    """
+    register a before scenario hook that will execute before every scenario has
+    executed and we will pass the current behave context object as the only
+    argument to the hook_func provided.
+    """
+    CONFIG["__CUCU_BEFORE_SCENARIO_HOOKS"].append(hook_func)
+
+
+def register_after_scenario_hook(hook_func):
+    """
+    register an after scenario hook that will execute after every scenario has
+    executed and we will pass the current behave context object as the only
+    argument to the hook_func provided.
+    """
+    CONFIG["__CUCU_AFTER_SCENARIO_HOOKS"].append(hook_func)
+
+
+def register_after_this_scenario_hook(hook_func):
+    """
+    register an after scenario hook that will only once after the next scenario
+    has executed and we will pass the current behave context object as the only
+    argument to the hook_func provided.
+    """
+    CONFIG["__CUCU_AFTER_THIS_SCENARIO_HOOKS"].append(hook_func)
+
+
+def register_before_step_hook(hook_func):
+    """
+    register a before step hook that will execute before every step is executed
+    and we will pass the current behave context object as the only argument to
+    the hook_func provided.
+    """
+    CONFIG["__CUCU_BEFORE_STEP_HOOKS"].append(hook_func)
+
+
+def register_after_step_hook(hook_func):
+    """
+    register an after step hook that will execute after every step executes and
+    we will pass the current behave context object as the only argument to the
+    hook_func provided.
+    """
+    CONFIG["__CUCU_AFTER_STEP_HOOKS"].append(hook_func)
+
+
+def register_page_check_hook(name, hook_func):
+    """
+    register a hook to run after every "page load", a "page load" event isn't
+    accurate but we try to simply check the page after every interaction such as
+    clicking or navigating.
+
+    parameters:
+        name(string):        name used when logging for the page check
+        hook_func(function): function called with the current
+                             `cucu.browser.Browser` instance
+    """
+    CONFIG["__CUCU_PAGE_CHECK_HOOKS"][name] = hook_func
+
+
+def register_custom_variable_handling(regex, lookup):
+    """
+    register a regex to match variable names on and allow the lookup
+    function provided to do the handling of the resolution of the variable
+    name.
+
+    parameters:
+        regex(string): regular expression to match on any config variable
+                       name when doing lookups
+        lookup(func): a function that accepts a variable name to return its
+                      value at runtime.
+
+                      def lookup(name):
+                        return [value of the variable at runtime]
+    """
+    CONFIG.register_custom_variable_handling(regex, lookup)
+
+
+def register_custom_tags_in_report_handling(regex, handler):
+    """
+    register a regex to match tag names when generating the HTML test report
+    and the function provided will process the exact tag found and return
+    the HTML/text to place in the report when a tag that matches the provided
+    regex is found.
+
+    parameters:
+        regex(string): regular expression to match on any tag name in the HTML
+                       test report.
+        handler(func): a function that accepts the complete tag name (ie @foo)
+                       and returns the exact value to put in the HTMl test
+                       report (HTML/text).
+
+                      def handle(tag):
+                        return "<a href="...">{tag}</a>"
+    """
+    CONFIG["__CUCU_HTML_REPORT_TAG_HANDLERS"][re.compile(regex)] = handler
+
+
+def register_custom_scenario_subheader_in_report_handling(handler):
+    """
+    register a handler to add HTML content under the scenario header.
+
+    parameters:
+        handler(func): a function that accepts the scenario and returns a HTML to
+                       go below the scenario header
+
+                      def handle(scenario):
+                        return f"<div>this is below the {scenario['name']}'s header</div>"
+    """
+    CONFIG["__CUCU_HTML_REPORT_SCENARIO_SUBHEADER_HANDLER"].append(handler)
+
+
+def register_custom_junit_failure_handler(handler):
+    """
+    register a callback function to call when there is a test failure and
+    we want to augment the failure output message in the junit results
+    files.
+
+    parameters:
+        handler(feature, scenario):
+          where feature and scenario are the following behave model
+          objects:
+
+            * https://behave.readthedocs.io/en/stable/api.html#behave.model.Feature
+            * https://behave.readthedocs.io/en/stable/api.html#behave.model.Scenario
+
+          You must return a string that will be appended to the top of the
+          failure message in the JUnit XML results files.
+    """
+    CONFIG["__CUCU_CUSTOM_FAILURE_HANDLERS"].append(handler)
+
+
+def register_before_retry_hook(hook_func):
+    """
+    register an before retry hook that will execute before retrying
+    cucu.utils.retry function call. The arguments passed to the provided hook
+    are only the current behave context object.
+
+    parameters:
+        handler(ctx): a method that accepts the current behave context and
+                      executes whatever it needs to before a retryable call is
+                      about to be retried.
+
+                      def handle(ctx):
+                        ctx.do_something()
+    """
+    CONFIG["__CUCU_BEFORE_RETRY_HOOKS"].append(hook_func)

cucu/language_server/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+# nopycln: file
+from cucu.language_server.core import start

cucu/language_server/core.py

@@ -0,0 +1,114 @@
+import logging
+import re
+from importlib import metadata
+
+import jellyfish
+from lsprotocol.types import (
+    TEXT_DOCUMENT_COMPLETION,
+    CompletionItem,
+    CompletionList,
+    CompletionOptions,
+    CompletionParams,
+)
+from pygls.server import LanguageServer
+
+from cucu import init_global_hook_variables
+from cucu.cli.steps import load_cucu_steps
+
+init_global_hook_variables()
+
+
+def find_completions(step_fragment, steps_cache=None):
+    """
+    given a step name fragment return all of the possible step name completions
+    for that fragment.
+
+    Params:
+        step_fragment(string): prefix of the step name to look for such as
+                             "I click"
+
+    Returns:
+        an Array tuples of step name and locations.
+    """
+    items = []
+
+    if steps_cache is None:
+        steps_cache, _ = load_cucu_steps()
+
+    # first pass try to find steps that start with fragment provided
+    for step in steps_cache.keys():
+        if step.startswith(step_fragment):
+            step_details = steps_cache[step]
+            location = step_details["location"]
+            location = f"{location['filepath']}:{location['line']}"
+            items.append((step, location))
+
+    # if there were 0 steps found then lets at least find some that are close
+    # based on some string distance heuristic
+    if len(items) == 0:
+        for step in steps_cache.keys():
+            if jellyfish.jaro_similarity(step_fragment, step) > 0.6:
+                step_details = steps_cache[step]
+                location = step_details["location"]
+                location = f"{location['filepath']}:{location['line']}"
+                items.append((step, location))
+
+        def compare_completion_item(completion_item):
+            return jellyfish.jaro_similarity(completion_item[0], step_fragment)
+
+        items.sort(key=compare_completion_item, reverse=True)
+
+    return items
+
+
+def start(port=None):
+    version = metadata.version(__package__.split(".")[0])
+    server = LanguageServer(name="cucu", version=version)
+    steps_cache, _ = load_cucu_steps()
+    logging.basicConfig(
+        filename="pygls.log", filemode="w", level=logging.DEBUG
+    )
+
+    @server.feature(
+        TEXT_DOCUMENT_COMPLETION, CompletionOptions(trigger_characters=[","])
+    )
+    def completions(ls: LanguageServer, params: CompletionParams):
+        logging.warn(f"{TEXT_DOCUMENT_COMPLETION}: {params}")
+
+        document_uri = params.text_document.uri
+        document = document_lines = ls.workspace.get_document(document_uri)
+        document_lines = document.source.split("\n")
+
+        completion_line = document_lines[params.position.line]
+        logging.debug(f'completions for "{completion_line}"')
+
+        completion_line = completion_line.lstrip()
+        step_line = re.match(
+            "(Given|When|Then|And) (.*)", completion_line
+        ).groups()[1]
+
+        items = []
+        step_completions = find_completions(
+            completion_line, steps_cache=steps_cache
+        )
+
+        for step_name, step_location in step_completions:
+            insert_text = step_name.replace(step_line, "")
+            items.append(
+                CompletionItem(
+                    label=step_name,
+                    detail=f"defined in {step_location}",
+                    insert_text=insert_text,
+                )
+            )
+
+        return CompletionList(
+            is_incomplete=False,
+            items=items,
+        )
+
+    if port:
+        server.start_tcp("0.0.0.0", int(port))
+
+    else:
+        server.start_io()