cucu 1.0.0__py3-none-any.whl

cucu/formatter/junit.py

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+import os
+import traceback
+from datetime import datetime
+from xml.sax.saxutils import escape
+
+import bs4
+from behave.formatter.base import Formatter
+from behave.model_core import Status
+from bs4.formatter import XMLFormatter
+from tenacity import RetryError
+
+from cucu.config import CONFIG
+from cucu.utils import ellipsize_filename
+
+
+class CucuJUnitFormatter(Formatter):
+    name = "cucu-junit"
+    description = "JUnit Formater"
+
+    def __init__(self, stream_opener, config):
+        super(CucuJUnitFormatter, self).__init__(stream_opener, config)
+        self.xml_root = None
+        self.current_feature = None
+        self.current_scenario = None
+        self.curent_step = None
+        self.current_scenario_traceback = None
+        self.current_scenario_duration = 0.0
+        self.current_scenario_results = {}
+        self.feature_timestamp = None
+        self.steps = []
+
+    # -- FORMATTER API:
+    def uri(self, uri):
+        pass
+
+    def feature(self, feature):
+        self.current_feature = feature
+        date_now = datetime.now()
+        self.feature_results = {
+            "name": escape(feature.name),
+            "foldername": escape(ellipsize_filename(feature.name)),
+            "tests": 0,
+            "errors": 0,
+            "failures": 0,
+            "skipped": 0,
+            "timestamp": date_now.strftime("%Y-%m-%dT%H:%M:%S.%f%z"),
+            "scenarios": {},
+        }
+        if feature.tags:
+            self.feature_results["tags"] = ", ".join(feature.tags)
+
+    def background(self, background):
+        # -- ADD BACKGROUND STEPS: Support *.feature file regeneration.
+        for step_ in background.steps:
+            self.step(step_)
+
+    def update_scenario(self):
+        if self.current_scenario is not None:
+            self.current_scenario_results["time"] = str(
+                round(self.current_scenario_duration, 3)
+            )
+            hook_failed = self.current_scenario.hook_failed
+            if hook_failed:
+                status = "errored"
+            else:
+                status = self.current_scenario.compute_status().name
+
+            self.current_scenario_results["status"] = status
+            failures = []
+
+            if status == "failed" and self.current_scenario_traceback:
+                failure_handlers = CONFIG["__CUCU_CUSTOM_FAILURE_HANDLERS"]
+
+                for failure_handler in failure_handlers:
+                    failures.append(
+                        failure_handler(
+                            self.current_feature, self.current_scenario
+                        )
+                    )
+
+                failures += [
+                    f"{self.current_step.keyword} {self.current_step.name} (after {round(self.current_step.duration, 3)}s)"
+                ]
+
+                if error := self.current_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__
+                        error_lines = error.args[0].splitlines()
+                        error_lines[0] = (
+                            f"{error_class_name}: {error_lines[0]}"
+                        )
+                    else:
+                        error_lines = [repr(error)]
+                    failures += error_lines
+
+                if CONFIG["CUCU_JUNIT_WITH_STACKTRACE"] == "true":
+                    failures += traceback.format_tb(
+                        self.current_scenario_traceback
+                    )
+
+                self.current_scenario_results["failure"] = failures
+
+            if status == "skipped":
+                self.current_scenario_results["skipped"] = True
+
+    def scenario(self, scenario):
+        self.update_scenario()
+
+        self.current_scenario = scenario
+        self.current_scenario_traceback = None
+        self.current_scenario_duration = 0.0
+        self.current_scenario_results = {
+            "status": "pending",
+            "time": "n/a",
+            "failure": None,
+            "skipped": None,
+        }
+        self.current_scenario_results["foldername"] = escape(
+            ellipsize_filename(scenario.name)
+        )
+        if scenario.tags:
+            self.current_scenario_results["tags"] = ", ".join(scenario.tags)
+
+        scenario_name = escape(scenario.name)
+        self.feature_results["scenarios"][scenario_name] = (
+            self.current_scenario_results
+        )
+
+        # we write out every new scenario into the JUnit results output
+        # which allows us to have a valid JUnit XML results file per feature
+        # file currently running even if the process crashes or is killed so we
+        # can still generate valid reports from every run.
+        self.write_results(self.feature_results)
+
+    def match(self, step):
+        pass
+
+    def step(self, step):
+        self.steps.append(step)
+
+    def insert_step(self, step, index=-1):
+        if index == -1:
+            self.steps.append(step)
+        else:
+            self.steps.insert(index, step)
+
+    def result(self, step):
+        self.current_step = step
+        if step.status == Status.failed:
+            self.current_scenario_traceback = step.exc_traceback
+
+        self.current_scenario_duration += step.duration
+
+    def eof(self):
+        """
+        end of file for the feature and this is when we write the updated
+        results to the file
+        """
+        self.update_scenario()
+        self.write_results(self.feature_results)
+
+    def close(self):
+        pass
+
+    def write_results(self, results):
+        """
+        given a feature results dictionary that looks like so:
+            {
+                "name": "name of the feature",
+                "foldername": "",
+                "tests": 0,
+                "errors": 0,
+                "failures": 0,
+                "skipped": 0,
+                "timestamp": "",
+                "scenarios": {
+                    "scenario name": {
+                        "foldername": "",
+                        "tags": "DOM-3435, testrail(3366,45891)",
+                        "status": "passed/failed/skipped",
+                        "time": "0.0000":
+                        "stdout": "",
+                        "stderr": "",
+                    },
+                    ...
+                }
+            }
+        """
+
+        # custom attribute ordering so attributes are printed in a consistent
+        # and desired order
+        class SortAttributes(XMLFormatter):
+            def attributes(self, tag):
+                ordered = [
+                    "classname",
+                    "name",
+                    "foldername",
+                    "tests",
+                    "errors",
+                    "failures",
+                    "skipped",
+                    "status",
+                    "timestamp",
+                    "time",
+                    "tags",
+                ]
+
+                return [
+                    (attr, tag[attr]) for attr in ordered if attr in tag.attrs
+                ]
+
+        soup = bs4.BeautifulSoup()
+        testsuite = bs4.Tag(name="testsuite")
+        testsuite["name"] = results["name"]
+        testsuite["foldername"] = results["foldername"]
+        testsuite["timestamp"] = results["timestamp"]
+
+        junit_dir = CONFIG["CUCU_JUNIT_DIR"]
+        os.makedirs(junit_dir, exist_ok=True)
+
+        feature_name = results["name"]
+        output_filepath = os.path.join(junit_dir, f"{feature_name}.xml")
+
+        scenarios = results["scenarios"]
+
+        if CONFIG["CUCU_SHOW_SKIPS"] != "true":
+            filtered_scenarios = {}
+
+            for name, scenario in scenarios.items():
+                if scenario["status"] != "skipped":
+                    filtered_scenarios[name] = scenario
+
+            scenarios = filtered_scenarios
+
+            if len(scenarios) == 0:
+                # we had a suite of just skipped results
+                return
+
+        # calculate with the latest data
+        testsuite["tests"] = len(scenarios)
+        testsuite["failures"] = len(
+            [x for x in scenarios.values() if x["status"] == Status.failed]
+        )
+        testsuite["skipped"] = len(
+            [x for x in scenarios.values() if x["status"] == Status.skipped]
+        )
+        testsuite["errors"] = len(
+            [
+                x
+                for x in scenarios.values()
+                if x["status"]
+                not in (Status.failed, Status.skipped, Status.passed)
+            ]
+        )
+
+        if "tags" in results:
+            testsuite["tags"] = results["tags"]
+        soup.append(testsuite)
+
+        for scenario_name in scenarios:
+            scenario = scenarios[scenario_name]
+            testcase = bs4.Tag(name="testcase")
+            testcase["classname"] = results["name"]
+            testcase["name"] = scenario_name
+            testcase["foldername"] = scenario["foldername"]
+            if "tags" in scenario:
+                testcase["tags"] = scenario["tags"]
+            testcase["status"] = scenario["status"]
+            testcase["time"] = scenario["time"]
+
+            if scenario["failure"] is not None:
+                failure_message = "\n".join(scenario["failure"])
+                failure = bs4.Tag(name="failure")
+                failure.append(bs4.CData(failure_message))
+                testcase.append(failure)
+
+            if scenario["skipped"] is not None:
+                testcase.append(bs4.Tag(name="skipped"))
+
+            testsuite.append(testcase)
+
+        feature_name = results["name"]
+        output_filepath = os.path.join(junit_dir, f"{feature_name}.xml")
+        with open(output_filepath, "w", encoding="utf-8") as output:
+            output.write(soup.prettify(formatter=SortAttributes()))

cucu/fuzzy/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+# nopycln: file
+from .core import init, find, load_jquery_lib, load_fuzzy_lib, Direction

cucu/fuzzy/core.py

@@ -0,0 +1,107 @@
+import pkgutil
+from enum import Enum
+
+from cucu import logger
+from cucu.browser.frames import search_in_all_frames
+
+
+def load_jquery_lib():
+    """
+    load jquery library
+    """
+    jquery_lib = pkgutil.get_data(
+        "cucu", "external/jquery/jquery-3.5.1.min.js"
+    )
+    return jquery_lib.decode("utf8")
+
+
+def load_fuzzy_lib():
+    """
+    load the fuzzy javascript library
+    """
+    return pkgutil.get_data("cucu", "fuzzy/fuzzy.js").decode("utf8")
+
+
+def init(browser):
+    """
+    initializes the fuzzy matching javascript library within the currently open
+    browsers execution engine
+
+    parameters:
+        browser - ...
+    """
+    script = "return typeof cucu !== 'undefined' && typeof cucu.fuzzy_find === 'function';"
+    cucu_injected = browser.execute(script)
+    if cucu_injected:
+        # cucu fuzzy find already exists
+        return
+
+    logger.debug("inject cucu fuzzy find library to the browser")
+    jqCucu_script = "window.jqCucu = jQuery.noConflict(true);"
+    browser.execute(load_jquery_lib() + jqCucu_script + load_fuzzy_lib())
+
+
+class Direction(Enum):
+    """
+    simple Direction enum
+    """
+
+    LEFT_TO_RIGHT = 1
+    RIGHT_TO_LEFT = 2
+
+
+def find(
+    browser,
+    name,
+    things,
+    index=0,
+    direction=Direction.LEFT_TO_RIGHT,
+    name_within_thing=False,
+):
+    """
+    find an element by applying the fuzzy finding rules when given the name
+    that identifies the element on screen and a list of possible `things` that
+    are CSS expression fragments like so:
+
+        tag_name[attribute expression]
+
+    That identify the kind of element you're trying to find, such as a button,
+    input[type='button'], etc.
+
+    parameters:
+      browser           - the cucu.browser.Browser object
+      name              - name that identifies the element you are trying to find
+      things            - array of CSS fragments that specify the kind of elements you
+                          want to match on
+      index             - which of the many matches to return
+      direction         - the text to element direction to apply fuzzy in. Default we
+                          apply right to left but for checkboxes or certain languages
+                          this direction can be used to find things by prioritizing
+                          matching from "left to right"
+      name_within_thing - to determine if the name has to be within the web element
+
+    returns:
+        the WebElement that matches the provided arguments.
+    """
+    browser.switch_to_default_frame()
+
+    # always need to protect names in which double quotes are used as below
+    # we pass arguments to the fuzzy_find javascript function wrapped in double
+    # quotes
+    name = name.replace('"', '\\"')
+    name_within_thing = "true" if name_within_thing else "false"
+
+    args = [
+        f'"{name}"',
+        str(things),
+        str(index),
+        str(direction.value),
+        name_within_thing,
+    ]
+
+    def execute_fuzzy_find():
+        init(browser)
+        script = f"return cucu.fuzzy_find({','.join(args)});"
+        return browser.execute(script)
+
+    return search_in_all_frames(browser, execute_fuzzy_find)

cucu/fuzzy/fuzzy.js

@@ -0,0 +1,253 @@
+(function(){
+    window.cucu = {
+        debug: false
+    };
+
+    /*
+     * custom jquery matchers:
+     *
+     *
+     *  has_text - matches an element with the exact text provided.
+     *
+     *  vis      - matches an element that is visible and has at least
+     *             one visible parent.
+     *
+     */
+    jqCucu.extend(
+        jqCucu.expr[ ":" ],
+        {
+            has_text: function(elem, index, match) {
+                return (elem.textContent || elem.innerText || jqCucu(elem).text() || '').trim() === match[3].trim();
+            },
+            vis: function (elem) {
+                return !(jqCucu(elem).is(":hidden") || jqCucu(elem).css("width") == "0px" || jqCucu(elem).css("height") == "0px" || jqCucu(elem).parents(":hidden").length);
+            }
+        }
+    );
+
+    // this matches the class Direction in  cucu/fuzzy/core.py
+    const LEFT_TO_RIGHT = 1;
+    const RIGHT_TO_LEFT = 2;
+
+    /*
+     * find an element by applying the fuzzy finding rules when given the name
+     * that identifies the element on screen and a list of possible `things` that
+     * are CSS expression fragments like so:
+     *
+     *     tag_name[attribute expression]
+     *
+     * That identify the kind of element you're trying to find, such as a button,
+     * input[type='button'], etc.
+     *
+     * parameters:
+     *   name              - name that identifies the element you are trying to find
+     *   things            - array of CSS fragments that specify the kind of elements
+     *                       you want to match on
+     *   index             - which of the many matches to return
+     *   direction         - the text to element direction to apply fuzzy in. Default
+     *                       we apply right to left but for checkboxes or certain
+     *                       languages this direction can be used to find things by
+     *                       prioritizing matching from "left to right"
+     *   name_within_thing - to determine if the name has to be within the web element
+     */
+    cucu.fuzzy_find = function(name,
+                               things,
+                               index=0,
+                               direction=LEFT_TO_RIGHT,
+                               name_within_thing=false) {
+        var elements = [];
+        var results = null;
+        var attributes = ['aria-label', 'title', 'placeholder', 'value'];
+        var matchers = ['has_text', 'contains'];
+
+        name = name.replaceAll('"', '\\"')
+
+        /*
+         * try to match on exact text but ultimately fall back to matching on
+         * the elements text that contains the string we're searching for
+         */
+        for(var mIndex=0; mIndex < matchers.length; mIndex++) {
+            var matcher = matchers[mIndex];
+
+            /*
+             * element labeled in itself or by its own attributes
+             */
+            for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                var thing = things[tIndex];
+
+                /*
+                 * <thing>name</thing>
+                 */
+                results = jqCucu(thing + ':vis:' + matcher + '("' + name + '")', document.body).toArray();
+                if (cucu.debug) { console.log('<thing>name</thing>', results); }
+                elements = elements.concat(results);
+
+                // <thing attribute="name"></thing>
+                for(var aIndex=0; aIndex < attributes.length; aIndex++) {
+                    var attribute_name = attributes[aIndex];
+                    if (matcher == 'has_text') {
+                        results = jqCucu(thing + '[' + attribute_name + '="' + name + '"]:vis', document.body).toArray();
+                        if (cucu.debug) { console.log('<thing attribute="name"></thing>', results); }
+                    } else if (matcher == 'contains') {
+                        results = jqCucu(thing + '[' + attribute_name + '*="' + name + '"]:vis', document.body).toArray();
+                        if (cucu.debug) { console.log('<thing attribute*="name"></thing>', results); }
+                    }
+                    elements = elements.concat(results);
+                }
+            }
+
+            /*
+             * validate against the `value` attribute of the actual DOM object
+             * as that has the value that may have changed from having written
+             * a new value into an input which doesn't get reflected in the DOM.
+             *
+             * TODO: I think there may be a cleaner way to handle this but for
+             *       now lets just add another loop in here.
+             */
+            for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                var thing = things[tIndex];
+
+                // <thing value="name"></thing>
+                if (matcher == 'has_text') {
+                    results = jqCucu(thing + ':vis', document.body).filter(function(){
+                        return this.value == name;
+                    }).toArray();
+                    if (cucu.debug) { console.log('<thing value="name"></thing>', results); }
+                } else if (matcher == 'contains') {
+                    results = jqCucu(thing + ':vis', document.body).filter(function(){
+                        return this.value !== undefined && String(this.value).indexOf(name) != -1;
+                    }).toArray();
+                    if (cucu.debug) { console.log('<thing value*="name"></thing>', results); }
+                }
+                elements = elements.concat(results);
+            }
+
+            /*
+             * element labeled by another using the for/id attributes
+             */
+            var labels = jqCucu('*[for]:vis:' + matcher + '("' + name + '")', document.body).toArray();
+            for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                var thing = things[tIndex];
+                results = [];
+
+                /*
+                 * <* for=...>name</*>...<thing id=...></thing>
+                 */
+                for(var lIndex=0; lIndex < labels.length; lIndex++) {
+                    var label = labels[lIndex];
+                    var id = label.getAttribute('for');
+                    results = jqCucu(thing + '[id="' + id + '"]:vis', document.body).toArray();
+                    if (cucu.debug) { console.log('<* for=...>name</*>...<thing id=...></thing>', results); }
+                    elements = elements.concat(results);
+                }
+            }
+
+            /*
+             * element labeled by a nested child
+             */
+            for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                var thing = things[tIndex];
+
+                /*
+                 * <thing><*>...name...</*></thing>
+                 */
+                results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).parents(thing).toArray();
+                if (cucu.debug) { console.log('<thing><*>...name...</*></thing>', results); }
+                elements = elements.concat(results);
+
+                // <thing><* attribute="name"></*></thing>
+                for(var aIndex=0; aIndex < attributes.length; aIndex++) {
+                    var attribute_name = attributes[aIndex];
+                    results = jqCucu('*:vis[' + attribute_name + '="' + name + '"]', document.body).parents(thing).toArray();
+                    if (cucu.debug) { console.log('<thing><* attibute="name"></*></thing>', results); }
+                    elements = elements.concat(results);
+                }
+            }
+
+            // if the name has to be within the element, the following rules are not considered
+            if (name_within_thing) {
+                continue;
+            }
+
+            // element labeled with direct previous sibling
+            if (direction === LEFT_TO_RIGHT) {
+                for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                    var thing = things[tIndex];
+
+                    // <*>name</*><thing/>
+                    results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).next(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log('<*>name</*><thing/>', results); }
+                    elements = elements.concat(results);
+                }
+            }
+
+            // element labeled with direct next sibling
+            if (direction === RIGHT_TO_LEFT) {
+                for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                    var thing = things[tIndex];
+
+                    // <thing/><*>name</*>
+                    results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).prev(thing).toArray();
+                    if (cucu.debug) { console.log('<thing/><*>name</*>', results); }
+                    elements = elements.concat(results);
+                }
+            }
+
+            /*
+             * element labeled by a text sibling
+             */
+            for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                var thing = things[tIndex];
+
+                /*
+                 * <*><thing></thing>name</*>
+                 */
+                results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).children(thing + ':vis').toArray();
+                if (cucu.debug) { console.log('<*><thing></thing>name</*>', results); }
+                elements = elements.concat(results);
+            }
+
+            // element labeled with any previous sibling
+            if (direction === LEFT_TO_RIGHT) {
+                for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                    var thing = things[tIndex];
+
+                    // <*>name</*>...<thing>...
+                    results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).nextAll(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log('<*>name</*>...<thing>...', results); }
+                    elements = elements.concat(results);
+
+                    // <...><*>name</*></...>...<...><thing></...>
+                    // XXX: this rule is horribly complicated and I'd rather see it gone
+                    //      basically: common great grandpranet
+                    results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).nextAll().find(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log('<...><*>name</*></...>...<...><thing></...>', results); }
+                    elements = elements.concat(results);
+                }
+            }
+
+            // element labeled with any next sibling
+            if (direction === RIGHT_TO_LEFT) {
+                for(var tIndex = 0; tIndex < things.length; tIndex++) {
+                    var thing = things[tIndex];
+
+                    // next siblings: <thing>...<*>name</*>...
+                    results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).prevAll(thing).toArray();
+                    if (cucu.debug) { console.log('<thing>...<*>name</*>...', results); }
+                    elements = elements.concat(results);
+
+                    // <...><thing></...>...<...><*>name</*></...>
+                    // XXX: this rule is horribly complicated and I'd rather see it gone
+                    results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).prevAll().find(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log('<...><thin></...>...<...><*>name</*></...>', results); }
+                    elements = elements.concat(results);
+                }
+            }
+        }
+
+        if (cucu.debug) {
+            console.log(elements);
+        }
+        return elements[index];
+    };
+})();