首页 > 编程语言 >界面自动化测试录制工具，让python selenium自动化测试脚本开发更加方便

界面自动化测试录制工具，让python selenium自动化测试脚本开发更加方便

时间：2024-07-29 11:07:15浏览次数：7  
标签：xpath name python attribute value let 测试 自动化 parameter

自动化测试中，QTP和selenium IDE都支持浏览器录制与回放功能，简单的来说就像一个记录操作步骤的机器人，可以按照记录的步骤重新执行一遍，这就是脚本录制。
个人觉得传统录制工具有些弊端，加上要定制支持我自己的自动化框架（python单机版自动化测试框架源代码），所以自己用javascript写了一个录制工具，在控制台打印记录的python脚本如下：

 

代码如下（初稿，还在不断调试完善中）：

var click_textContent = '
    var father_level = 0;
    var child_ctl = "";
    var child_ctl_tmp = "";
    var next_focusedElement = null;
    window.clickedElement = null;
    
    document.addEventListener("click", function(event) {
    window.clickedElement = event.target;
    console.log(window.clickedElement);
    father_level = 0;
    myDispose_click(window.clickedElement);
    });
    
    function myDispose_click(focusedElement) {
        console.log(`开始 父${father_level} -------------------------`);
        let tag_name = focusedElement.tagName.toLowerCase();
        let outerHTML = focusedElement.outerHTML;
        console.log(outerHTML);
        
        if (tag_name === "body") {
            let xpath = getElementfullXPath(next_focusedElement);
            let elements = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
            if (elements && elements.snapshotLength === 1) {
                console.log(`self.myWtClickEx(driver, By.XPATH, "${xpath}")`);
                console.log("结束：tag名称为body");
                console.log(`结束 父${father_level} -------------------------`);
                return xpath;
            } else {
                console.log("结束：tag名称为body");
                console.log(`结束 父${father_level} -------------------------`);
                return null;
            }
        }

        let my_all_value = "";
        let text = focusedElement.textContent.trim().replace(/"/g, "\\\"");
        if (text !== "" && !text.includes("\\n")) {
            my_all_value = `contains(text(),\'${text}\')`;
            if (myDispose_count_number(text, "text", tag_name)) {
                let xpath = `//${tag_name}[${my_all_value}]`;
                let parameter = `driver, By.XPATH, "${xpath}"`;
                myDispose_success(parameter);
                return parameter;
            }
        } else {
            text = ""
        }

        let attributes = focusedElement.attributes;
        console.log(`属性名称列表: ${Array.from(attributes).map(attr => attr.name).join(",")}`);

        for (let i = 0; i < attributes.length; i++) {
            let attribute_name = attributes[i].name;
            let attribute_value = attributes[i].value;

            if (attribute_name === "class") {
                let class_value_list = attribute_value.split(" ");
                console.log(`class列表：${class_value_list}`);
                if (class_value_list.includes("focusing")) {
                    class_value_list = class_value_list.filter(value => value !== "focusing");
                }

                for (let class_value of class_value_list) {
                    if (my_all_value === "") {
                        my_all_value = `contains(@class,"${class_value}")`;
                    } else {
                        my_all_value += ` and contains(@class,"${class_value}")`;
                    }
                
                    if (myDispose_count_number(class_value, attribute_name, tag_name)) {
                        let parameter = `driver, By.CLASS_NAME, "${class_value}"`;
                        myDispose_success(parameter);
                        return parameter;
                    }
                    
                    let xpath = "";
                    if (text === "") {
                        xpath = `//${tag_name}[${my_all_value}]`;
                    } else {
                        xpath = `//${tag_name}[contains(text(),\'${text}\') and ${my_all_value}]`;
                    }
                    let result = myDispose_count_evaluate(xpath);
                    if (result) { 
                        let parameter = `driver, By.XPATH, "${xpath}"`;
                        myDispose_success(parameter);
                        return parameter;
                    }
                }
            } else {
                /*if (attribute_value === "" || /\d/.test(attribute_value)) {*/
                if (attribute_value === "" || (attribute_name !== "src" && attribute_value.match(/[0-9]/))) {
                    continue;
                }

                if (my_all_value === "") {
                    my_all_value = `contains(@${attribute_name}, "${attribute_value}")`;
                } else {
                    my_all_value += ` and contains(@${attribute_name}, "${attribute_value}")`;
                }
                
                if (myDispose_count_number(attribute_value, attribute_name, tag_name)) { 
                    let xpath = `//${tag_name}[contains(@${attribute_name}, "${attribute_value}")]`;
                    let parameter = `driver, By.XPATH, "${xpath}"`;
                    myDispose_success(parameter);
                    return parameter;
                }
                
                let xpath = "";
                if (text === "") {
                    xpath = `//${tag_name}[${my_all_value}]`;
                } else {
                    xpath = `//${tag_name}[contains(text(),\'${text}\') and ${my_all_value}]`;
                }
                let result = myDispose_count_evaluate(xpath);
                if (result) {
                    let parameter = `driver, By.XPATH, "${xpath}"`;
                    myDispose_success(parameter);
                    return parameter;
                }
            }
        }

        if (my_all_value !== "") {
            let xpath = `//${tag_name}[${my_all_value}]`;
            let result = myDispose_count_evaluate(xpath);
            if (result) {
                let parameter = `driver, By.XPATH, "${xpath}"`;
                myDispose_success(parameter);
                return parameter;
            } else {
                let textStr = `self.myWtClickEx(driver, By.XPATH, "${xpath}")`;
                console.log("# 不是1");
                console.log(textStr);
                console.log(`结束 父${father_level} -------------------------`);
                
                if (father_level === 0) {
                    child_ctl = `father, By.XPATH, ".${xpath}"`;
                    child_ctl_tmp = `.${xpath}`;
                    next_focusedElement = focusedElement;
                }

                let father = focusedElement.parentElement;
                if (father) {
                    father_level++;
                    myDispose_click(father);
                }
            }
        }
        return null;
    }

    function myDispose_success(parameter) {
        if (father_level === 0) {
            console.log(`self.myWtClickEx(${parameter})`);
        } else {
            console.log(`father = self.myWtFindElement(${parameter})`);
            console.log(`self.myWtClickEx(${child_ctl})`);
        }
        console.log(`结束 父${father_level} -------------------------`);
    }

    function myDispose_count_evaluate(xpath) {
        let elements = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
        if (father_level === 0) {
            if (elements.snapshotLength === 1) {
                return true
            } else {
                return null
            }
        } else {
            if (elements.snapshotLength === 1) {
                let firstElement = elements.snapshotItem(0);
                let result = document.evaluate(child_ctl_tmp, firstElement, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
                if (result.snapshotLength === 1) {
                    return true
                } else {
                    return null
                }
            } else {
                return null
            }
        }
    }

    function myDispose_count_number(attribute_value, attribute_name, tag_name) {
        if (attribute_value === "") {
            return null;
        };
        if (attribute_name !== "text" && attribute_name !== "src" && attribute_value.match(/[0-9]/)) {
            return null;
        };

        let xpath;
        if (attribute_name !== "text") {
            xpath = `//${tag_name}[contains(@${attribute_name}, "${attribute_value}")]`;
        } else {
            xpath = `//${tag_name}[contains(text(), \'${attribute_value}\')]`;
        };
        
        let result = myDispose_count_evaluate(xpath);

        if (result) {
            console.log(`${attribute_name}："${attribute_value}" 在网页中出现1次`);
            return true;
        } else {
            console.log(`${attribute_name}："${attribute_value}" 在网页中出现了多次`);
            return null;
        };
    }

    function getElementfullXPath(element) {
        if (element && element.id)
            if (!element.id.match(/[0-9]/)) {
                return \'//*[@id="\' + element.id + \'"]\';
            }
            
        if (element==null)
            return "";
    
        var index = 0;
        var loacl_tagName = element.tagName;
        var sibling = element.previousSibling;
        var sibling_tagName = null;
        if (sibling) {
            sibling_tagName = sibling.tagName;
        }
        while (sibling && sibling.nodeType === 1 && loacl_tagName === sibling_tagName) {
            index++;
            sibling = sibling.previousSibling;
            if (sibling) {
                sibling_tagName = sibling.tagName;
            } else {
                sibling_tagName = null;
            }
        }
        
        parent = element.parentNode;
        if (parent) {
            var xpath = getElementfullXPath(parent);
            if (xpath === "undefined") {
                return "";
            } else {
                if (index === 0) {
                    xpath += "/" + element.tagName.toLowerCase();
                } else {
                    xpath += "/" + element.tagName.toLowerCase() + "[" + (index+1) + "]";
                }
                return xpath;
            }
        } else {
            return "";
        }
    }
';


var input_textContent = '
    let inputs = document.querySelectorAll(`input[type="text"]`);
    inputs.forEach(input => {
        input.addEventListener("input", function(event) {
            console.log(this.value);
            let parameter = myDispose_click(event.target);
            if (parameter !== null) {
                let textStr = `self.myWtSendKeysWebEx(${parameter}, "${this.value}")`;
                console.log(textStr);
            }
        });
    }); 
';


/*iframe*/
let iframes = document.getElementsByTagName('iframe');
for (let i = 0; i < iframes.length; i++) {
    let iframe = iframes[i];
    if (iframe.contentWindow && iframe.contentWindow.document) {
        let script = iframe.contentWindow.document.createElement('script');
        script.type = 'text/javascript';
        script.textContent = click_textContent;
        iframe.contentWindow.document.head.appendChild(script);
        let inputs = iframe.contentWindow.document.querySelectorAll(`input[type="text"]`);
        inputs.forEach(input => {
            input.addEventListener("input", function(event) {
                console.log(this.value);
                let parameter = myDispose_click(event.target);
                if (parameter !== null) {
                    let textStr = `self.myWtSendKeysWebEx(${parameter}, "${this.value}")`;
                    console.log(textStr);
                }
            });
        });
    }
}


/*非iframe*/
let script = document.createElement('script');
script.type = 'text/javascript';
script.textContent = click_textContent + input_textContent;
document.head.appendChild(script);

 

标签：xpath,name,python,attribute,value,let,测试,自动化,parameter
From： https://www.cnblogs.com/rmticocean/p/18329662

相关文章

  • Python 面试常问问题及应用场景解析
    引言随着Python在数据科学、Web开发、自动化脚本、机器学习等领域中的广泛应用，越来越多的公司开始寻找具备Python技能的人才。因此，在Python面试中，面试官通常会通过一系列问题来评估应聘者的编程基础、问题解决能力和对Python特性的理解程度。本文将涵盖Python面试中最常见的......
  • python 虚拟环境
    python虚拟环境Python的venv模块允许你创建轻量级的“虚拟环境”，这些环境是独立的Python安装，用于项目的依赖隔离。每个虚拟环境都有自己的Python解释器、库和脚本，与系统中安装的Python相互隔离。这意呀着，你可以在一个项目中安装特定版本的库，而不会影响到系统上其他Pyt......
  • 使用 Azure Devops API (Python) 撰写 PR 评论
    在任何地方都找不到直接的方法。如何通过Python中的AzureDevopsAPI将注释添加到拉取请求？可以使用AzureDevOpsPythonAPI将注释添加到拉取请求。以下是执行此操作的方法：1.安装AzureDevOps库：pipinstallazure-devops2.导入必要的类并对的组......
  • Python\Python312\Lib\site-packages\torch\lib\fbgemm.dll
    在此处输入图像描述我正在尝试从HuggingFace导入GPT-2变压器模型，但当我尝试导入它时，遇到错误。即使当我尝试仅导入Torch时，我也会收到相同的错误。我已尝试重新安装Torch并完成了所有操作，包括更新VisualC++Redistributable软件包和更新我的驱动程序，但问题......
  • Python GEKKO 不更新参数
    我正在Python中使用GEKKO来估计弹跳球的轨迹。为此，我需要估计2个变量：e_1（恢复系数）和q_1（每次弹跳时的水平速度损失）。我已为其编写了以下代码，但参数似乎没有更新，尽管解算器已成功执行。参数的初始值与参数的最终优化值相同e_1=0.8和q_1=1代码：imp......
  • Python内置模块常用总结
    目录unittestunittest点击查看代码importunittestfromhtmltestreportimportHTMLTestReportclassTestOne(unittest.TestCase):@classmethoddefsetUpClass(cls)->None:print(f'setUpClass')@classmethoddeftearDownClass......
  • 你的职业发展提速器：霍兰德职业兴趣测试的秘诀
    简介霍兰德职业兴趣自测（Self-DirectedSearch）是由美国职业指导专家霍兰德（JohnHolland）根据他本人大量的职业咨询经验及其职业类型理论编制的测评工具。霍兰德认为，个人职业兴趣特性与职业之间应有一种内在的对应关系。根据兴趣的不同，人格可分为研究型（I）、艺术型（A）、社会型（S）、企......
  • 使用 warpPerspective 生成​​全景图像并使用 python 进行单应拼接
    我没有获得正确的全景图像，并且图像质量随着图像的缝合而降低。我期待获得正确的360度图像，并且不会因正确拼接而降低质量。当我使用网络摄像头图像时。它应该得到没有不匹配的拼接图像。我正在研究匹配FCFS中的图像或最佳匹配的方法。创建并添加一个输入图像以及image1和im......
  • 通过 python 获取 android.view.ViewGroup 中的子项
    是否可以使用python、adb或任何库从android.view.ViewGroup获取子元素或文本，但不需要java和kotlin？我正在尝试使用python自动化android模拟器。与模拟器的交互通过adb进行。当我得到屏幕转储时，我看到我需要的元素是android.view.ViewGroup，并且text和content-......
  • 嵌入式开发测试实训室解决方案
    一、建设背景随着物联网、人工智能等技术的飞速发展，嵌入式系统作为这些技术的重要载体，其重要性日益凸显。为了满足市场对嵌入式技术人才的需求，培养具有扎实理论基础、熟练实践技能及创新能力的嵌入式开发工程师，设计并建设一个高效、全面的嵌入式开发测试实训室显得尤为重......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99