cucu 1.3.8__tar.gz → 1.3.10__tar.gz

{cucu-1.3.8 → cucu-1.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cucu
-Version: 1.3.8
+Version: 1.3.10
 Summary: Easy BDD web testing
 Keywords: cucumber,selenium,behave
 Author: Domino Data Lab, Rodney Gomes, Cedric Young, Xin Dong, Kavya Yakkati, Kevin Garton, Joy Liao

{cucu-1.3.8 → cucu-1.3.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cucu"
-version = "1.3.8"
+version = "1.3.10"
 description = "Easy BDD web testing"
 readme = "README.md"
 license = { text = "The Clear BSD License" }

{cucu-1.3.8 → cucu-1.3.10}/src/cucu/ansi_parser.py

@@ -25,12 +25,13 @@ TRANSLATION = (
         ESC_SEQ + "55": "",  # ignore HOME (num keypad)
         ESC_SEQ + "56": "",  # ignore UP ARROW (num keypad)
         ESC_SEQ + "57": "",  # ignore PAGE UP (num keypad)
+        ESC_SEQ + "1A": "",  # ignore move cursor up one line
     }
 )
 RE_TO_HTML = re.compile("|".join(map(re.escape, TRANSLATION)))
 
 RE_TO_REMOVE = re.compile(
-    r"\x1b\[(0;)?[0-9A-F]{1,2}m"
+    r"\x1b\[(0;)?[0-9A-F]{1,2}[mA]:?"
 )  # detect hex values, not just decimal digits
 
 

{cucu-1.3.8 → cucu-1.3.10}/src/cucu/db.py

@@ -123,16 +123,16 @@ class step(BaseModel):
     duration = FloatField(null=True)
     start_at = DateTimeField(null=True)
     end_at = DateTimeField(null=True)
-    stdout = JSONField(null=True)
-    stderr = JSONField(null=True)
+    stdout = JSONField()
+    stderr = JSONField()
     error_message = JSONField(null=True)
     exception = JSONField(null=True)
-    debug_output = TextField(null=True)
-    browser_info = JSONField(null=True)
+    debug_output = TextField()
+    browser_info = JSONField()
     text = JSONField(null=True)
     table_data = JSONField(null=True)
     location = TextField()
-    browser_logs = TextField(null=True)
+    browser_logs = TextField()
     screenshots = JSONField(null=True)
 
 
@@ -213,6 +213,11 @@ def start_step_record(step_obj, scenario_run_id):
         is_substep=getattr(step_obj, "is_substep", False),
         has_substeps=getattr(step_obj, "has_substeps", False),
         section_level=getattr(step_obj, "section_level", None),
+        browser_info="",
+        browser_logs="",
+        debug_output="",
+        stderr=[],
+        stdout=[],
     )
 
 

{cucu-1.3.8 → cucu-1.3.10}/src/cucu/formatter/junit.py

@@ -10,6 +10,7 @@ from behave.model_core import Status
 from bs4.formatter import XMLFormatter
 from tenacity import RetryError
 
+from cucu.ansi_parser import remove_ansi
 from cucu.config import CONFIG
 from cucu.utils import ellipsize_filename
 
@@ -286,7 +287,8 @@ class CucuJUnitFormatter(Formatter):
             if scenario["failure"] is not None:
                 failure_message = "\n".join(scenario["failure"])
                 failure = bs4.Tag(name="failure")
-                failure.append(bs4.CData(failure_message))
+                cleaned_failure_message = remove_ansi(failure_message)
+                failure.append(bs4.CData(cleaned_failure_message))
                 testcase.append(failure)
 
             if scenario["skipped"] is not None:

{cucu-1.3.8 → cucu-1.3.10}/src/cucu/formatter/rundb.py

@@ -132,6 +132,8 @@ class RundbFormatter(Formatter):
     def scenario(self, scenario):
         """Called before a scenario is executed (or ScenarioOutline scenarios)."""
         self._finish_scenario()
+        # Set after CONFIG.restore() in environment.before_scenario()
+        CONFIG["FEATURE_RUN_ID"] = scenario.feature.feature_run_id
 
         self.this_scenario = scenario
         self.this_steps = []
@@ -139,7 +141,9 @@ class RundbFormatter(Formatter):
         scenario_run_id_seed = (
             f"{scenario.feature.feature_run_id}_{time.perf_counter()}"
         )
-        scenario.scenario_run_id = generate_short_id(scenario_run_id_seed)
+        CONFIG["SCENARIO_RUN_ID"] = scenario.scenario_run_id = (
+            generate_short_id(scenario_run_id_seed)
+        )
         scenario.custom_data = {}
 
         # feature.scenarios is a mix of Scenario and ScenarioOutline objects with their own scenarios list

{cucu-1.3.8 → cucu-1.3.10}/src/cucu/fuzzy/core.py

@@ -97,6 +97,7 @@ def find(
         str(index),
         str(direction.value),
         name_within_thing,
+        "true"
     ]
 
     def execute_fuzzy_find():
@@ -104,4 +105,9 @@ def find(
         script = f"return cucu.fuzzy_find({','.join(args)});"
         return browser.execute(script)
 
-    return search_in_all_frames(browser, execute_fuzzy_find)
+    fuzzy_return = search_in_all_frames(browser, execute_fuzzy_find)
+    if fuzzy_return is None:
+        logger.info("Fuzzy found no element.")
+        return None
+    logger.info("Fuzzy found element by search term {}".format(fuzzy_return[1]))
+    return fuzzy_return[0]

{cucu-1.3.8 → cucu-1.3.10}/src/cucu/fuzzy/fuzzy.js

@@ -54,13 +54,15 @@
                                things,
                                index=0,
                                direction=LEFT_TO_RIGHT,
-                               name_within_thing=false) {
+                               name_within_thing=false,
+                               insert_label=false) {
         var elements = [];
+        var element_labels = [];
         var results = null;
         var attributes = ['aria-label', 'title', 'placeholder', 'value'];
         var matchers = ['has_text', 'contains'];
 
-        name = name.replaceAll('"', '\\"')
+        name = name.replaceAll('"', '\\"');
 
         /*
          * try to match on exact text but ultimately fall back to matching on
@@ -75,24 +77,27 @@
             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); }
+                var nameInTagContentLabel = `<${thing}>${name}</${thing}>`;
+                var nameInTagContentJq = `${thing}:vis:${matcher}("${name}")`;
+                results = jqCucu(nameInTagContentJq, document.body).toArray();
+                if (cucu.debug) { console.log(nameInTagContentLabel, results); }
                 elements = elements.concat(results);
+                element_labels = element_labels.concat(results.map(x => nameInTagContentLabel));
 
-                // <thing attribute="name"></thing>
                 for(var aIndex=0; aIndex < attributes.length; aIndex++) {
                     var attribute_name = attributes[aIndex];
+                    var nameIsAttributeLabel = `<${thing} attribute="${attribute_name}"></${thing}>`;
                     if (matcher == 'has_text') {
-                        results = jqCucu(thing + '[' + attribute_name + '="' + name + '"]:vis', document.body).toArray();
-                        if (cucu.debug) { console.log('<thing attribute="name"></thing>', results); }
+                        var nameIsAttributeJq = `${thing}[${attribute_name}="${name}"]:vis`;
+                        results = jqCucu(nameIsAttributeJq, document.body).toArray();
+                        if (cucu.debug) { console.log(nameIsAttributeLabel, 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); }
+                        var nameInAttributeJq = `${thing}[${attribute_name}*="${name}"]:vis`;
+                        results = jqCucu(nameInAttributeJq, document.body).toArray();
+                        if (cucu.debug) { console.log(nameIsAttributeLabel, results); }
                     }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => nameIsAttributeLabel));
                 }
             }
 
@@ -107,38 +112,44 @@
             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(){
+                    var nameIsValueLabel = `${thing} value="${name}"></${thing}>`;
+                    var nameIsValueJq = `${thing}:vis`;
+                    results = jqCucu(nameInValueJq, document.body).filter(function(){
                         return this.value == name;
                     }).toArray();
-                    if (cucu.debug) { console.log('<thing value="name"></thing>', results); }
+                    if (cucu.debug) { console.log(nameIsValueLabel, results); }
                 } else if (matcher == 'contains') {
-                    results = jqCucu(thing + ':vis', document.body).filter(function(){
+                    var nameInValueLabel = `${thing} value*="${name}"></${thing}>`;
+                    var nameInValueJq = `${thing}:vis`;
+                    results = jqCucu(nameInValueJq, 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); }
+                    if (cucu.debug) { console.log(nameInValueLabel, results); }
                 }
                 elements = elements.concat(results);
+                element_labels = element_labels.concat(results.map(x => nameInValueLabel));
             }
 
             /*
              * element labeled by another using the for/id attributes
              */
-            var labels = jqCucu('*[for]:vis:' + matcher + '("' + name + '")', document.body).toArray();
+            var labelForNameJq = `*[for]:vis:${matcher}("${name}")`
+            var labels = jqCucu(labelForNameJq, document.body).toArray();
             for(var tIndex = 0; tIndex < things.length; tIndex++) {
                 var thing = things[tIndex];
                 results = [];
 
-                /*
-                 * <* for=...>name</*>...<thing id=...></thing>
-                 */
+                var labelForNameLabel = `<* 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); }
+                    var idMatchesForLabelJq = `${thing}[id="${id}"]:vis`;
+                    results = jqCucu(idMatchesForLabelJq, document.body).toArray();
+
+                    if (cucu.debug) { console.log(labelForNameLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => labelForNameLabel));
                 }
             }
 
@@ -148,19 +159,23 @@
             for(var tIndex = 0; tIndex < things.length; tIndex++) {
                 var thing = things[tIndex];
 
-                /*
-                 * <thing><*>...name...</*></thing>
-                 */
+                var nameInNestedChildLabel = `<${thing}><*>...${name}...</*></${thing}>`;
                 results = jqCucu('*:vis:' + matcher + '("' + name + '")', document.body).parents(thing).toArray();
-                if (cucu.debug) { console.log('<thing><*>...name...</*></thing>', results); }
+                if (cucu.debug) { console.log(nameInNestedChildLabel, results); }
                 elements = elements.concat(results);
+                if (results.length > 0) {
+                   console.log('!*!*!* Found element labeled by nested child!');
+                   console.log(`!*!*!* elements: ${elements}`);
+                }
+                element_labels = element_labels.concat(results.map(x => nameInNestedChildLabel));
 
-                // <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); }
+                    var innerNestedElementsLabel = `<${thing}><* ${attribute_name}="${name}"></*></${thing}>`;
+                    results = jqCucu(`*:vis[${attribute_name}="${name}"]`, document.body).parents(thing).toArray();
+                    if (cucu.debug) { console.log(innerNestedElementsLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => innerNestedElementsLabel));
                 }
             }
 
@@ -174,10 +189,11 @@
                 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); }
+                    var nameIsPreviousSiblingLabel = `<*>${name}</*><${thing}/>`;
+                    results = jqCucu(`*:vis:${matcher}("${name}")`, document.body).next(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log(nameIsPreviousSiblingLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => nameIsPreviousSiblingLabel));
                 }
             }
 
@@ -186,10 +202,11 @@
                 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); }
+                    var nameIsNextSiblingLabel = `<${thing}/><*>${name}</*>`;
+                    results = jqCucu(`*:vis:${matcher}("${name}")`, document.body).prev(thing).toArray();
+                    if (cucu.debug) { console.log(nameIsNextSiblingLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => nameIsNextSiblingLabel));
                 }
             }
 
@@ -199,12 +216,11 @@
             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); }
+                var nameIsTextSiblingLabel = `<*><${thing}></${thing}>${name}</*>`;
+                results = jqCucu(`*:vis:${matcher}("${name}")`, document.body).children(thing + ':vis').toArray();
+                if (cucu.debug) { console.log(nameIsTextSiblingLabel, results); }
                 elements = elements.concat(results);
+                element_labels = element_labels.concat(results.map(x => nameIsTextSiblingLabel));
             }
 
             // element labeled with any previous sibling
@@ -212,17 +228,19 @@
                 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); }
+                    var leftToRightLabel = `<*>${name}</*>...<${thing}>...`;
+                    results = jqCucu(`*:vis:${matcher}("${name}")`, document.body).nextAll(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log(leftToRightLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => leftToRightLabel));
 
-                    // <...><*>name</*></...>...<...><thing></...>
+                    var leftToRightGrandpaLabel = `<...><*>${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); }
+                    results = jqCucu(`*:vis:${matcher}("${name}")`, document.body).nextAll().find(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log(leftToRightGrandpaLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => leftToRightGrandpaLabel));
                 }
             }
 
@@ -231,22 +249,29 @@
                 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); }
+                    var rightToLeftLabel = `<${thing}>...<*>${name}</*>...`;
+                    results = jqCucu(`*:vis:${matcher}("${name}")`, document.body).prevAll(thing).toArray();
+                    if (cucu.debug) { console.log(rightToLeftLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => rightToLeftLabel));
 
-                    // <...><thing></...>...<...><*>name</*></...>
+                    var rightToLeftGrandpaLabel = `<...><${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); }
+                    results = jqCucu(`*:vis:${matcher}("${name}")`, document.body).prevAll().find(thing + ':vis').toArray();
+                    if (cucu.debug) { console.log(rightToLeftGrandpaLabel, results); }
                     elements = elements.concat(results);
+                    element_labels = element_labels.concat(results.map(x => rightToLeftGrandpaLabel));
                 }
             }
         }
 
         if (cucu.debug) {
             console.log(elements);
+            console.log(element_labels);
+        }
+
+        if (elements.length > 0 && insert_label) {
+            return [elements[index], element_labels[index]];
         }
         return elements[index];
     };

{cucu-1.3.8 → cucu-1.3.10}/src/cucu/reporter/templates/scenario.html

@@ -87,6 +87,9 @@
             {% endif %}
             {% if step['result'] is defined %}
                 {% set step_status = step['result']['status'] %}
+                {% if step['result']['status'] == 'skipped' %}
+                    {% set step_status = 'untested' %}
+                {% endif %}
                 {% if step['result']['status'] in ('failed', 'passed') and step["result"]["timestamp"] %}
                     {% set step_timing = "{} for {:.3f}s".format(step["result"]["timestamp"].strftime("%H:%M:%S"), step["result"]["duration"]) %}
                     {% set step_start = step["result"]["timestamp"] %}