selenium+java自动化测试框架之元素管理篇（yaml）

最新推荐文章于 2024-12-26 14:45:03 发布
转载 最新推荐文章于 2024-12-26 14:45:03 发布 · 1.3k 阅读 · 2

元素对象管理：

元素对象（以下称为locator）的维护与管理很麻烦，因为locator比较多，每个页面上要操作的可能有几十个，如何快速的查找及维护好能够使我们写脚本的速度及维护速度大大提升。在前端开发中，开发人员通常是把UI样式放在CSS文件中，受此影响，我们也可以把我们的locator放在一个专门的文件中，按照页面来分类，提取其公共的locator放在公共的文件中，这样或许可以提升些许编写脚本速度及后期维护成本，效果就是如果UI变了，我们只需要修改对应的页面中的locator就行了，脚本都不需要重新编译（如果是用需要编译的语言，如JAVA）,下面我将介绍一下如何放在专门的文件中，如何解析该文件，及在脚本中如何调用。下面的脚本语言为JAVA。

  1. 文件类型------yaml

  2. java解析yaml文件所需要的jar包:jyaml-1.3.jar，需自已在网上下载。
  3. 格式介绍：
    a. baidu_input后面接上":",直接回车，然后空两格
    b. type与value这两个key是固定的，后面接上":",然后空一格，也可以不空，如果value后面是xpath，建议用加上引号，具体去看下yaml的格式，百度一大堆。
    c. 在webdriver中，有By.id,By.name,By.xpath,By.className,By.linkText等，我们选取这几种常见的，所以type的冒包后面可用的值为id,name,xpath
    d. value的值为type中对应的类型的值，比如百度首页上的输入框的id='kw',所以在yaml文件中的写法如上图所示
  4. 解析上述的yaml文件：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    import org.ho.yaml.Yaml;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.util.HashMap;
     
    public class Demo {
     
        private String yamlFile;
     
        public Demo() {    
            yamlFile = "demo";
            this.getYamlFile();
        }
     
        private HashMap<String, HashMap<String, String>> ml;   
     
        @SuppressWarnings("unchecked")
        public void getYamlFile() {
            File f = new File("locator/" + yamlFile + ".yaml");
            try {
                ml = Yaml.loadType(new FileInputStream(f.getAbsolutePath()),
                        HashMap.class);
            }catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }  
    }

    可以在本地创建一个demo.yaml文件，保存在locator目录中，locator与src同级目录，然后写个main方法来调用一个getYamlFile方法，可以看到解析demo.yaml后的值都赋给了变量ml。解析过程如此简单，解析速度如此之快，yaml文件也比较直观，这是我选择用yaml文件的原因，当然可能还有其它更好的选择，大家可以自行尝试。

  5. 我们在写脚本时，元素对象一般是这样写的WebElement element = driver.findElement(By.id("kw"));所以接下来我们要把ml变量里的"value"转换成By对象。添加如下代码
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    private By getBy(String type, String value) {
        By by = null;
        if (type.equals("id")) {
            by = By.id(value);
        }
        if (type.equals("name")) {
            by = By.name(value);
        }
        if (type.equals("xpath")) {
            by = By.xpath(value);
        }
        if (type.equals("className")) {
            by = By.className(value);
        }
        if (type.equals("linkText")) {
            by = By.linkText(value);
        }
        return by;
    }

     这样通过ml中的type与value的值就对产生一个By对象。

  6. By对象产生后，就可以把这个对象传给driver.findElement方法，继而生成一个WebElement对象.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    import org.ho.yaml.Yaml;
    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
     
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.util.HashMap;
     
    public class Demo {
     
        private String yamlFile;
        public WebDriver driver;
         
        public Demo() {
            driver = DriverInstance.getInstance();
            yamlFile = "demo";
            this.getYamlFile();
        }
     
        private HashMap<String, HashMap<String, String>> ml;   
     
        @SuppressWarnings("unchecked")
        public void getYamlFile() {
            File f = new File("locator/" + yamlFile + ".yaml");
            try {
                ml = Yaml.loadType(new FileInputStream(f.getAbsolutePath()),
                        HashMap.class);
            }catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
         
        private By getBy(String type, String value) {
            By by = null;
            if (type.equals("id")) {
                by = By.id(value);
            }
            if (type.equals("name")) {
                by = By.name(value);
            }
            if (type.equals("xpath")) {
                by = By.xpath(value);
            }
            if (type.equals("className")) {
                by = By.className(value);
            }
            if (type.equals("linkText")) {
                by = By.linkText(value);
            }
            return by;
        }
         
        public WebElement getElement(String key) {
            String type = ml.get(key).get("type");
            String value = ml.get(key).get("value");
            return driver.findElement(this.getBy(type, value));
        }
         
        public static void main(String[] args){
            Demo d = new Demo();
            WebElement element = d.getElement("baidu_input");
            element.sendKeys("");
        }
    }

     

  7. 到这里，已经成功了一半，因为已经把yaml文件中保存的元素成功的转化成了WebElement对象。但是还不够，接下来我们引入一下同步点的概念，就是在调用locator时，保证locator是显示在页面上的，webdriver中有个WebDriverWait对象，代码如下：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
       private WebElement watiForElement(final By by) {
        WebElement element = null;
        int waitTime = Integer.parseInt(Config.getConfig("waitTime"));
        try {
            element = new WebDriverWait(driver, waitTime)
                    .until(new ExpectedCondition<WebElement>() {
                        public WebElement apply(WebDriver d) {
                            return d.findElement(by);
                        }
                    });
        }catch (Exception e) {
            System.out.println(by.toString() + " is not exist until " + waitTime);
        }
        return element;
    }

    于是乎getElement方法里面就可以改为

    1
    2
    3
    4
    5
       public WebElement getElement(String key) {
       String type = ml.get(key).get("type");
       String value = ml.get(key).get("value");
       return this.watiForElement(this.getBy(type, value));
    }   

     

  8. 到这一步，又改进了一点，新的问题也随之产生了，watiForElement这个方法，返回的WebElement对象包括隐藏的，如果是隐藏的，那么在操作的时候，自然而然会报错，所以，我们得把隐藏的去掉，只显示displayed的元素对象，增加一个方法。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    private boolean waitElementToBeDisplayed(final WebElement element) {
        boolean wait = false;
        if (element == null)
            return wait;
        try {
            wait = new WebDriverWait(driver, Integer.parseInt(Config
                    .getConfig("waitTime")))
                    .until(new ExpectedCondition<Boolean>() {
                        public Boolean apply(WebDriver d) {
                            return element.isDisplayed();
                        }
                    });
        }catch (Exception e) {
            System.out.println(element.toString() + " is not displayed");
        }
        return wait;
    }

    如此一来，getElement方法又可以改进一下了。

    1
    2
    3
    4
    5
    6
    7
    8
    public WebElement getElement(String key) {
        String type = ml.get(key).get("type");
        String value = ml.get(key).get("value");
        WebElement element = this.watiForElement(this.getBy(type, value));
        if(!this.waitElementToBeDisplayed(element))
            element = null;
        return element;
    }

     

  9. 既然有等待元素对象显示的，那么反之就有等待元素对象消失的方法。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public boolean waitElementToBeNonDisplayed(final WebElement element) {
        boolean wait = false;
        if (element == null)
            return wait;
        try {
            wait = new WebDriverWait(driver, Integer.parseInt(Config
                    .getConfig("waitTime")))
                    .until(new ExpectedCondition<Boolean>() {
                        public Boolean apply(WebDriver d) {
                            return !element.isDisplayed();
                        }
                    });
        }catch (Exception e) {
            System.out.println("Locator [" + element.toString()
                    +"] is also displayed");
        }
        return wait;
    }

     

  10. 看上去一切很美好了，but....如果我们要验证一个元素对象不出现在页面上，就会出现问题了，于是增加一个方法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public WebElement getElementNoWait(String key) {
        WebElement element = null;
        String type = ml.get(key).get("type");
        String value = ml.get(key).get("value");
        try{
            element = driver.findElement(this.getBy(type, value));
        }catch(Exception e){
            element = null;
        }
        return element;
    }

     

  11. 现在的问题是getElement与getElementNoWait的方法体很接近，于是我们来重构下这部分的代码，先增加一个方法，存放相同的方法体
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    private WebElement getLocator(String key, boolean wait) {
        WebElement element = null;
        if (ml.containsKey(key)) {
            HashMap<String, String> m = ml.get(key);
            String type = m.get("type");
            String value = m.get("value");         
            By by = this.getBy(type, value);
            if (wait) {
                element = this.watiForElement(by);
                boolean flag = this.waitElementToBeDisplayed(element);
                if (!flag)
                    element = null;
            }else {
                try {
                    element = driver.findElement(by);
                }catch (Exception e) {
                    element = null;
                }
            }
        }else
            System.out.println("Locator " + key + " is not exist in " + yamlFile
                    +".yaml");
        return element;
    }

    再把getElement与getElementNoWait方法进行修改

    1
    2
    3
    4
    5
    6
    7
    public WebElement getElement(String key) {     
        return this.getLocator(key,true);
    }
     
    public WebElement getElementNoWait(String key) {
        return this.getLocator(key,false);
    }

     

  12. 到现在为止，已经可以满足绝大部分的需求了，完全可以使用了，下面的任务就是来点锦上添花了，举个例子，在yaml文件中，允许使用参数，比如
    1
    2
    3
    4
    5
    6
    baidu_input:
      type: id
      value:"%s%s"
    baidu_button:
      type: id
      value:"%s"

    在这里面的参数用%s来表示，于是在脚本中，我们调用getElement与getElementNoWait方法时需要我们把value给传进去，我们再来处理下这部分，增加一个方法。

    1
    2
    3
    4
    5
    6
    private String getLocatorString(String locatorString, String[] ss) {
        for (String s : ss) {
            locatorString = locatorString.replaceFirst("%s", s);
        }
        return locatorString;
    }

    在上面的方法中，我们可以看到，对于value值，我们是通过一个数组循环的去替代里面的%s,再把该方法结合到getLocator方法中去。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    private WebElement getLocator(String key, String[] replace, boolean wait) {
        WebElement element = null;
        if (ml.containsKey(key)) {
            HashMap<String, String> m = ml.get(key);
            String type = m.get("type");
            String value = m.get("value");
            if (replace != null)
                value = this.getLocatorString(value, replace);
            By by = this.getBy(type, value);
            if (wait) {
                element = this.watiForElement(by);
                boolean flag = this.waitElementToBeDisplayed(element);
                if (!flag)
                    element = null;
            }else {
                try {
                    element = driver.findElement(by);
                }catch (Exception e) {
                    element = null;
                }
            }
        }else
            System.out.println("Locator " + key + " is not exist in " + yamlFile
                    +".yaml");
        return element;
    }

    可以看到getLocator方法的参数变了，于是要重新的更改getElement与getElementNoWait方法，同时重载这两个方法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public WebElement getElement(String key) {
        return this.getLocator(key,null,true);
    }
     
    public WebElement getElementNoWait(String key) {
        return this.getLocator(key,null,false);
    }
     
    public WebElement getElement(String key, String[] replace) {
        return this.getLocator(key, replace, true);
    }
     
    public WebElement getElementNoWait(String key, String[] replace) {
        return this.getLocator(key, replace, false);
    }

     

  13. 惊喜？更大的还在后面。再举个例子：
    1
    2
    3
    4
    5
    6
    baidu_input:
      type: xpath
      value:"//div[@id='%productId%']//div"
    baidu_button:
      type: xpath
      value:"//div[@id='%productId%']//input[@name='button']"

    类似于上面这种，整个里面都含有productId, 于是我们可以通过一个方法，调用这个方法后，里面的都会被替换掉，该方法如下。

    1
    2
    3
    4
    5
    6
    7
    public void setLocatorVariableValue(String variable, String value){
        Set<String> keys = ml.keySet();
        for(String key:keys){
             String v = ml.get(key).get("value").replaceAll("%"+variable+"%", value);
             ml.get(key).put("value",v);
        }
    }
  14. 再比如，有一些元素对象是每个页面都会出现的，是公共的，这些公共的locator只是有时候要用到，大部分时候都不用，所以，我们把这些公共的放在一个特定的文件里，在需要的时候通过外部加载来使用这些公共的locator,增加一个变量与方法。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
        private HashMap<String, HashMap<String, String>> extendLocator;
    @SuppressWarnings("unchecked")
    public void loadExtendLocator(String fileName){
        File f = new File("locator/" + fileName + ".yaml");
        try {
            extendLocator = Yaml.loadType(new FileInputStream(f.getAbsolutePath()),
                    HashMap.class);
            ml.putAll(extendLocator);
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }   

     

  15. 到此为止，整个元素对象管理就结束了，这只是提供一个思路，大家如果有耐心从上到下的给按着来写一遍，应该会了解不少。最后来个总结性的代码。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    public class Page {
     
        public WebDriver driver;
     
        private String yamlFile;
     
        public Page() {
            driver = DriverInstance.getInstance();     
            yamlFile = "demo";
            this.getYamlFile();
        }
     
        private HashMap<String, HashMap<String, String>> ml;
         
        private HashMap<String, HashMap<String, String>> extendLocator;
     
        @SuppressWarnings("unchecked")
        protected void getYamlFile() {
            File f = new File("locator/" + yamlFile + ".yaml");
            try {
                ml = Yaml.loadType(new FileInputStream(f.getAbsolutePath()),
                        HashMap.class);
            }catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
         
        @SuppressWarnings("unchecked")
        public void loadExtendLocator(String fileName){
            File f = new File("locator/" + fileName + ".yaml");
            try {
                extendLocator = Yaml.loadType(new FileInputStream(f.getAbsolutePath()),
                        HashMap.class);
                ml.putAll(extendLocator);
            }catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
         
        public void setLocatorVariableValue(String variable, String value){
            Set<String> keys = ml.keySet();
            for(String key:keys){
                 String v = ml.get(key).get("value").replaceAll("%"+variable+"%", value);
                 ml.get(key).put("value",v);
            }
        }
     
        private String getLocatorString(String locatorString, String[] ss) {
            for (String s : ss) {
                locatorString = locatorString.replaceFirst("%s", s);
            }
            return locatorString;
        }
     
        private By getBy(String type, String value) {
            By by = null;
            if (type.equals("id")) {
                by = By.id(value);
            }
            if (type.equals("name")) {
                by = By.name(value);
            }
            if (type.equals("xpath")) {
                by = By.xpath(value);
            }
            if (type.equals("className")) {
                by = By.className(value);
            }
            if (type.equals("linkText")) {
                by = By.linkText(value);
            }
            return by;
        }
     
        private WebElement watiForElement(final By by) {
            WebElement element = null;
            int waitTime = Integer.parseInt(Config.getConfig("waitTime"));
            try {
                element = new WebDriverWait(driver, waitTime)
                        .until(new ExpectedCondition<WebElement>() {
                            public WebElement apply(WebDriver d) {
                                return d.findElement(by);
                            }
                        });
            }catch (Exception e) {
                System.out.println(by.toString() + " is not exist until " + waitTime);
            }
            return element;
        }
     
        private boolean waitElementToBeDisplayed(final WebElement element) {
            boolean wait = false;
            if (element == null)
                return wait;
            try {
                wait = new WebDriverWait(driver, Integer.parseInt(Config
                        .getConfig("waitTime")))
                        .until(new ExpectedCondition<Boolean>() {
                            public Boolean apply(WebDriver d) {
                                return element.isDisplayed();
                            }
                        });
            }catch (Exception e) {
                System.out.println(element.toString() + " is not displayed");
            }
            return wait;
        }
     
        public boolean waitElementToBeNonDisplayed(final WebElement element) {
            boolean wait = false;
            if (element == null)
                return wait;
            try {
                wait = new WebDriverWait(driver, Integer.parseInt(Config
                        .getConfig("waitTime")))
                        .until(new ExpectedCondition<Boolean>() {
                            public Boolean apply(WebDriver d) {
                                return !element.isDisplayed();
                            }
                        });
            }catch (Exception e) {
                System.out.println("Locator [" + element.toString()
                        +"] is also displayed");
            }
            return wait;
        }
     
        private WebElement getLocator(String key, String[] replace, boolean wait) {
            WebElement element = null;
            if (ml.containsKey(key)) {
                HashMap<String, String> m = ml.get(key);
                String type = m.get("type");
                String value = m.get("value");
                if (replace != null)
                    value = this.getLocatorString(value, replace);
                By by = this.getBy(type, value);
                if (wait) {
                    element = this.watiForElement(by);
                    boolean flag = this.waitElementToBeDisplayed(element);
                    if (!flag)
                        element = null;
                }else {
                    try {
                        element = driver.findElement(by);
                    }catch (Exception e) {
                        element = null;
                    }
                }
            }else
                System.out.println("Locator " + key + " is not exist in " + yamlFile
                        +".yaml");
            return element;
        }
     
        public WebElement getElement(String key) {
            return this.getLocator(key,null,true);
        }
     
        public WebElement getElementNoWait(String key) {
            return this.getLocator(key,null,false);
        }
     
        public WebElement getElement(String key, String[] replace) {
            return this.getLocator(key, replace, true);
        }
     
        public WebElement getElementNoWait(String key, String[] replace) {
            return this.getLocator(key, replace, false);
        }
    }

原文地址：http://www.cnblogs.com/zhangfei/p/3456159.html



自动化测试平台(十)：UI自动化元素页面的管理功能实现
曲鸟
01-06 5270
一、前言 上一章我们完成了列表组件公共化封装和项目管理功能的实现，这一章将实现用例概览页功能。 二、初始化数据 表结构模型代码如下： class UiPage(ComModel): id = models.AutoField(primary_key=True) name = models.CharField(max_length=32, verbose_name="页面名称") project = models.ForeignKey(to=Project, on_delete=mod
Selenium+Pytest自动化测试框架实战
MXB_1220的博客
07-26 670
首先我们上述这种较为原始的方法，基本不适用于平时做UI自动化测试的，因为在UI界面实际运行情况远远比较复杂，可能因为网络原因，或者控件原因，我们元素还没有显示出来，就进行点击或者输入。以上四种代码主体进行了拆分，虽然在用例很少的情况下做会增加代码，但是当用例多的时候意义很大，代码量会在用例增加的时候显著减少。但是还有一个问题，我们怎么样才能确保我们写的每一项元素不出错，人为的错误是不可避免的，但是我们可以通过代码来运行对文件的审查。对selenium的click，send_keys等方法，做了二次封装。
1.UI自动化测试框架搭建-yaml文件管理定位元素
测试游记
03-01 1022
介绍本框架基于Python语言进行开发，使用pytest管理用例运行，使用Jenkins+Allue进行脚本执行与报告展示。适用于Web、H5、IOS、安卓的UI自动化测试元素封装对于一个...
Web元素管理工具（Selenium）
03-15
使用winform管理自动化过程中的页面元素，含建库语句（Sql server），需要在config里面配置数据库连接字符串
教你如何写框架------元素管理篇
weixin_30673611的博客
12-03 384
前言： 我的博客从来都是言简意赅，直接步入正题。 元素对象管理： 元素对象（以下称为locator）的维护与管理很麻烦，因为locator比较多，每个页面上要操作的可能有几十个，如何快速的查找及维护好能够使我们写脚本的速度及维护速度大大提升。在前端开发中，开发人员通常是把UI样式放在CSS文件中，受此影响，我们也可以把我们的locator放在一个专门的文件中，按照页面来分类，提取其公共的lo...
自动化测试元素定位“最佳实践”
软件测试技术资源分享官
04-22 300
最近在翻阅cypress文档的时候发现一些关于自动化测试中元素定位的思考，觉得很有意思，这里跟大家分享一下。 核心概念 其实元素定义的核心概念很简单，一些元素总有自己独一无二的一些特点，比如我们每个人都有身份证号，利用这种独特性对元素进行定位，从而进一步做后续操作。 有道是君子有所为有所不为，一些在实践中被证明了是不合适的做法是最好不要去采用的，比如 不要使用有可能发生改变的属性对元素进行定位 。 如果你有能力修改前端代码，那么最佳实践就是: 加一个定位专用的属性，比如 data-* ，这个属性跟js逻辑以
基于Java Selenium的自动化测试框架设计源码，包含iframe及onlyread元素操作
最新发布
02-20
本项目是一个基于Java和Selenium的自动化测试框架的设计，它不仅提供了一套完整的源码，还特别包含了对iframe（内嵌框架）和只读元素（onlyread）的操作支持。Iframe是HTML中的一种标签，用于在当前页面内嵌入另一个...
2023最全最细的Selenium+Pytest自动化测试框架实战
m0_61046899的博客
06-30 1234
选前言# selenium自动化+ pytest测试框架本章你需要一定的python基础——至少明白类与对象，封装继承一定的selenium基础——本篇不讲selenium，不会的可以自己去看selenium中文翻译网测试框架简介# 测试框架有什么优点呢：代码复用率高，如果不使用框架的话，代码会很冗余 可以组装日志、报告、邮件等一些高级功能 提高元素等数据的可维护性，元素发生变化时，只需要更新一下配置文件 使用更灵活的PageObject设计模式 测试框架的整体目录 目录/文件 说明 是否为
Selenium + Pytest自动化测试框架实战！
MJH827的博客
12-26 1687
测试框架有什么优点呢：1.代码复用率高，如果不使用框架的话，代码会很冗余2.可以组装日志、报告、邮件等一些高级功能3.提高元素等数据的可维护性，元素发生变化时，只需要更新一下配置文件4.使用更灵活的PageObject设计模式【文末有配套资源免费获取！测试框架的整体目录这样一个简单的框架结构就清晰了。知道了以上这些我们就开始吧！我们在项目中先按照上面的框架指引，建好每一项目录。注意：python包为是的，都需要添加一个init.py文件以标识此目录为一个python包。
web自动化测试入门篇05——元素定位的配置管理
Austin的博客
02-10 2402
一般来说，界面元素的信息管理方法比较常见的有配置文件、持久化、专项平台和工具等。如何取舍大家也是众说纷纭，但既然我们使用了python这门语言，那么就要好好利用其优势，将管理的成本(人力、耗时等)降到最低。相较于一般文本，我们可以使用ini格式的配置文件来对已知晓具体信息的元素进行统一的管理，将业务代码与界面元素进行有效分离，减少后期因需求变动而发生的大量维护工作。
最小元素法
05-29
最小元素法，软考部分，分享给大家看看。
2022UI自动化测试框架搭建 —— yaml文件管理定位元素
03-09 4164
介绍 本框架基于Python语言进行开发，使用pytest管理用例运行，使用Jenkins+Allue进行脚本执行与报告展示。 适用于Web、H5、IOS、安卓的UI自动化测试 元素封装 对于一个需要定位的元素，我们一般就需要用到它的描述、定位方式、定位语句、使用时的变量名 由于部分元素出现时间较长，增加一个等待时间 我们编写一个Locator类，来描述一个定位元素 classLocator: """ 页面元素封装 """ def__init__(se...
Java+Selenium+Testng自动化学习（四）：元素获取及管理
qq_35332549的博客
04-01 1104
通过页面元素的固定属性，来确定元素。可以通过id，name，className，tagName，cssSelector，linkText，partialLinkText等属性来定位，不太好定位的元素，可以使用xpath方式。
元素管理器201809-3
_lilian_的博客
06-07 207
求解思路 关键点： 读入一行，并使用stringstream ss(tmp);进行分割 处理id选择器，可以放入map<string, int> mp;来进行映射，并记录当前行对应的id 记录当前标签的父亲结点，可以记录每个标签的前面的点数，从当前标签开始，向前搜索，当搜索到点数小于当前标签的点数时，则为当前标签的父亲 标签大小写不敏感，可以在写入结构体时，将所有标签字母转换成小写字母存储，匹配时也转换成小写字母进行匹配。 注意后代选择器可能有多个选择器，这些选择器都既可能是标签选择器，也可能
数据驱动之Yaml实现
weixin_45589713的博客
09-12 1127
一、背景：数据及配置文件之争 数据及文件通常有三种类型： 配置文件型：如ini，conf，properties文件，适合存储简单变量和配置项，最多支持两层，不适合存储多层嵌套数据 表格矩阵型：如csv，excel等，适合于存储大量同类数据，不适合存储层级结构的数据 多层嵌套型：如XML，HTMl，JSON、YAML，TOML等，适合存储单条或少数多层嵌套数据，不适合存储大量数据 YAML兼容JSON格式，简洁，强大，灵活，可以很方便的构造层级数据并快速转为Python中的字典。 二、YMAL简介 YAML（
Java+Selenium
m0_69050443的博客
07-27 9746
此处使用edge浏览器，在微软商店Selenium，然后下载浏览器对应版本的webDriver驱动包在idea中创建maven项目，pom文件引入selenium依赖在创建的测试类中，定义一个打开浏览器的方法System.setProperty是获取对应浏览器的驱动程序创建对应的驱动对象，通过get方法输入域名，就会自动打开浏览器访问它。
selenium+pytest:Web自动化Yaml工具类封装（二）
tianheihei__的博客
04-26 1351
web自动化测试框架之元素操作类封装
23种设计模式总结
热门推荐
lgxzzz的博客
05-25 8万+
一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛
python_selenium自动化测试框架
test的博客
09-18 1417
python_selenium自动化测试框架 设计思路 本文整理归纳以往的工作中用到的东西，现汇总成基础测试框架提供分享。 框架采用python3 + selenium3 + PO + yaml + ddt + unittest等技术编写成基础测试框架，能适应日常测试工作需要。 1、使用Page Object模式将页面定位和业务操作分开，分离测试对象（元素对象）和测试脚本（用例脚本），一个页面建一个对象类，提高用例的可维护性； 2、使用yaml管理页面控件元素数据和测试用例数据。例如元素ID等发.
基于TestNG和Selenium的Java自动化测试项目
根据所提供的文件信息——标题为“Repo_TestNGProjectWithJava:用于TestNG的Selenium项目相关工作”，描述内容一致，标签涵盖TestNG、Selenium、Java、自动化测试、测试框架、UI测试、单元测试、浏览器自动化、Maven...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值