cucu 1.0.0__py3-none-any.whl

cucu/steps/command_steps.py

@@ -0,0 +1,181 @@
+import atexit
+import os
+import shlex
+import subprocess
+import tempfile
+
+from cucu import config, logger, step
+
+
+def run_command(
+    command,
+    stdout_var=None,
+    stderr_var=None,
+    exit_code_var=None,
+    check_exit_code=None,
+):
+    args = shlex.split(command)
+    process = subprocess.run(args, capture_output=True)
+
+    if exit_code_var:
+        config.CONFIG[exit_code_var] = str(process.returncode)
+
+    stdout = process.stdout.decode("utf8")
+    stderr = process.stderr.decode("utf8")
+
+    if stdout_var:
+        config.CONFIG[stdout_var] = config.CONFIG.escape(stdout)
+
+    if stderr_var:
+        config.CONFIG[stderr_var] = config.CONFIG.escape(stderr)
+
+    return_code = process.returncode
+    if check_exit_code is not None and int(check_exit_code) != return_code:
+        logger.error(f"STDOUT:\n{stdout}\n")
+        logger.error(f"STDERR:\n{stderr}\n")
+        raise RuntimeError(
+            f"expected exit code {check_exit_code}, got {return_code}, see above for details"
+        )
+
+    else:
+        logger.debug(f"STDOUT:\n{stdout}\n")
+        logger.debug(f"STDERR:\n{stderr}\n")
+
+
+def run_script(
+    script,
+    stdout_var=None,
+    stderr_var=None,
+    exit_code_var=None,
+    check_exit_code=None,
+):
+    script_fd, script_filename = tempfile.mkstemp()
+    os.close(script_fd)
+    atexit.register(os.remove, script_filename)
+
+    with open(script_filename, "wb") as script_file:
+        script_file.write(script.encode())
+
+    os.chmod(script_filename, 0o755)
+    process = subprocess.run(
+        [script_file.name],
+        capture_output=True,
+        shell=True,
+    )  # nosec
+
+    if exit_code_var:
+        config.CONFIG[exit_code_var] = str(process.returncode)
+
+    stdout = process.stdout.decode("utf8")
+    stderr = process.stderr.decode("utf8")
+
+    if stdout_var:
+        config.CONFIG[stdout_var] = config.CONFIG.escape(stdout)
+
+    if stderr_var:
+        config.CONFIG[stderr_var] = config.CONFIG.escape(stderr)
+
+    return_code = process.returncode
+    if check_exit_code is not None and int(check_exit_code) != return_code:
+        logger.error(f"STDOUT:\n{stdout}\n")
+        logger.error(f"STDERR:\n{stderr}\n")
+        raise RuntimeError(
+            f"expected exit code {check_exit_code}, got {return_code}, see above for details"
+        )
+    else:
+        logger.debug(f"STDOUT:\n{stdout}\n")
+        logger.debug(f"STDERR:\n{stderr}\n")
+
+
+@step(
+    'I run the command "{command}" and save stdout to "{stdout_var}", stderr to "{stderr_var}", exit code to "{exit_code_var}"'
+)
+def runs_command_and_save_everything(
+    context, command, stdout_var, stderr_var, exit_code_var
+):
+    run_command(
+        command,
+        stdout_var=stdout_var,
+        stderr_var=stderr_var,
+        exit_code_var=exit_code_var,
+    )
+
+
+@step(
+    'I run the command "{command}" and save stdout to "{stdout_var}", stderr to "{stderr_var}" and expect exit code "{exit_code}"'
+)
+def runs_command_and_check_exit_code(
+    context, command, stdout_var, stderr_var, exit_code
+):
+    run_command(
+        command,
+        stdout_var=stdout_var,
+        stderr_var=stderr_var,
+        check_exit_code=exit_code,
+    )
+
+
+@step(
+    'I run the command "{command}" and save stdout to "{stdout_var}" and expect exit code "{exit_code}"'
+)
+def runs_command__and_save_stdout_and_check_exit_code(
+    context, command, stdout_var, exit_code
+):
+    run_command(
+        command,
+        stdout_var=stdout_var,
+        check_exit_code=exit_code,
+    )
+
+
+@step(
+    'I run the command "{command}" and save stdout to "{stdout_var}", exit code to "{exit_code_var}"'
+)
+def run_command_and_save_stdout_and_exit_code(
+    context, command, stdout_var, exit_code_var
+):
+    run_command(command, stdout_var=stdout_var, exit_code_var=exit_code_var)
+
+
+@step('I run the command "{command}" and save exit code to "{exit_code_var}"')
+def run_command_and_save_exit_code(context, command, exit_code_var):
+    run_command(command, exit_code_var=exit_code_var)
+
+
+@step('I run the command "{command}" and expect exit code "{exit_code}"')
+def run_command_and_expect_exit_code(context, command, exit_code):
+    run_command(command, check_exit_code=exit_code)
+
+
+@step(
+    'I run the following script and save stdout to "{stdout_var}", stderr to "{stderr_var}", exit code to "{exit_code_var}"'
+)
+def run_script_and_save_everything(
+    context, stdout_var, stderr_var, exit_code_var
+):
+    run_script(
+        context.text,
+        stdout_var=stdout_var,
+        stderr_var=stderr_var,
+        exit_code_var=exit_code_var,
+    )
+
+
+@step(
+    'I run the following script and save stdout to "{stdout_var}", stderr to "{stderr_var}" and expect exit code "{exit_code}"'
+)
+def run_script_and_check_exit_code(context, stdout_var, stderr_var, exit_code):
+    run_script(
+        context.text,
+        stdout_var=stdout_var,
+        stderr_var=stderr_var,
+        check_exit_code=exit_code,
+    )
+
+
+@step('I run the following script and expect exit code "{exit_code}"')
+def run_script_and_expect_exit_code(context, exit_code):
+    run_script(
+        context.text,
+        check_exit_code=exit_code,
+    )

cucu/steps/comment_steps.py

@@ -0,0 +1,17 @@
+from behave import use_step_matcher
+
+from cucu import step
+
+use_step_matcher("re")  # use regex to match comments
+
+
+@step("#.*")
+def comment_step(ctx):
+    """
+    A no-op step so that we can see "comments" in results and report.
+    Usage: add `* #` to the line you want to show up.
+    """
+    pass
+
+
+use_step_matcher("parse")  # set this back to cucu's default matcher parser

cucu/steps/draggable_steps.py

@@ -0,0 +1,168 @@
+from selenium.webdriver.support.ui import WebDriverWait
+
+from cucu import fuzzy, helpers, logger
+from cucu.utils import take_saw_element_screenshot
+
+
+def find_draggable_element(ctx, name, index=0):
+    """
+    find a draggable element on screen by fuzzy matching on the name provided
+    and the target element:
+
+        * <* draggable="true">
+
+    parameters:
+      ctx(object): behave context object used to share data between steps
+      name(str):   name that identifies the desired draggable element on screen
+      index(str):  the index of the draggable element if there are duplicates
+    returns:
+        the WebElement that matches the provided arguments.
+    """
+    ctx.check_browser_initialized()
+    element = fuzzy.find(
+        ctx.browser, name, ['*[draggable="true"]'], index=index
+    )
+
+    take_saw_element_screenshot(ctx, "draggable", name, index, element)
+
+    return element
+
+
+def is_draggable(element):
+    """
+    Checks if an element is draggable.
+    Args:
+        element (WebElement): The element to check.
+    Returns:
+        bool: True if the element is draggable, False otherwise.
+    """
+    return element.get_attribute("draggable") == "true"
+
+
+def is_not_draggable(element):
+    """
+    Checks if an element is not draggable.
+    Args:
+        element (WebElement): The element to check.
+    Returns:
+        bool: True if the element is not draggable, False otherwise.
+    """
+    return not is_draggable(element)
+
+
+def find_target_element(ctx, name, index=0):
+    ctx.check_browser_initialized()
+    _element = fuzzy.find(ctx.browser, name, ["*"], index=index)
+
+    return _element
+
+
+JS_DRAG_AND_DROP = """
+    const cucuDragAndDrop = async (dragElem, dropElem) => {
+
+    function triggerEvent(elem, eventName, dataTransfer = null) {
+        return new Promise((resolve) => {
+            const eventObj = new DragEvent(eventName, {
+                bubbles: true,
+                cancelable: true,
+                composed: true,
+                dataTransfer: dataTransfer,
+            });
+
+            function listener() {
+                resolve(eventObj);
+                elem.removeEventListener(eventName, listener);
+            }
+
+            elem.addEventListener(eventName, listener);
+            elem.dispatchEvent(eventObj);
+        });
+    }
+
+    const dragstartObj = await triggerEvent(dragElem, 'dragstart', new DataTransfer());
+    await triggerEvent(dropElem, 'dragenter', dragstartObj.dataTransfer);
+    const dropeventObj = await triggerEvent(dropElem, 'drop', dragstartObj.dataTransfer);
+    await triggerEvent(dragElem, 'dragend', dropeventObj.dataTransfer);
+
+    window.dragAndDropCompleted = true;
+    };
+
+    cucuDragAndDrop(arguments[0], arguments[1]);
+"""
+
+
+def drag_element_to_element(ctx, drag_name, drop_name):
+    driver = ctx.browser.driver
+
+    driver.execute_script("window.dragAndDropCompleted = false;")
+
+    start_drag_rect = drag_name.rect
+    logger.debug(
+        f"Start location of drag element {drag_name.text}: {start_drag_rect}"
+    )
+    logger.debug("Executing drag-and-drop via JavaScript.")
+
+    driver.execute_script(JS_DRAG_AND_DROP, drag_name, drop_name)
+
+    # Wait for the JavaScript flag to be set to True
+    WebDriverWait(driver, 10).until(
+        lambda driver: driver.execute_script(
+            "return window.dragAndDropCompleted;"
+        )
+    )
+
+    end_drag_rect = drag_name.rect
+    logger.debug(
+        f"End location of drag element {drag_name.text}: {end_drag_rect}"
+    )
+
+    if start_drag_rect == end_drag_rect:
+        raise RuntimeError(
+            f"Drag element {drag_name.text} position did not change"
+        )
+    else:
+        logger.debug("Drag element position changed successfully.")
+
+    logger.debug("Drag-and-drop operation executed.")
+
+
+helpers.define_thing_with_name_in_state_steps(
+    "element", "draggable", find_target_element, is_draggable
+)
+
+helpers.define_thing_with_name_in_state_steps(
+    "element", "not draggable", find_target_element, is_not_draggable
+)
+
+helpers.define_thing_with_name_in_state_steps(
+    "element", "draggable", find_target_element, is_draggable, with_nth=True
+)
+
+helpers.define_thing_with_name_in_state_steps(
+    "element",
+    "not draggable",
+    find_target_element,
+    is_not_draggable,
+    with_nth=True,
+)
+
+helpers.define_two_thing_interaction_steps(
+    "drag",
+    drag_element_to_element,
+    "element",
+    find_draggable_element,
+    "to",
+    "element",
+    find_target_element,
+)
+
+helpers.define_two_thing_interaction_steps(
+    "drag",
+    drag_element_to_element,
+    "element",
+    find_draggable_element,
+    "to",
+    "element",
+    find_target_element,
+    with_nth=True,
+)