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

最新推荐文章于 2024-04-23 18:52:22 发布
最新推荐文章于 2024-04-23 18:52:22 发布
阅读量4.1k 收藏 1
点赞数
分类专栏： selenium 文章标签： java 自动化 自动化测试

元素对象管理：

元素对象（以下称为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 );
         }
    }

lichao330530
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python使用yaml 管理selenium元素的示例
01-21
作者：做梦的人（小姐姐） 出处：https://www.cnblogs.com/chongyou/ 1.所有元素都在PageElement下的.yaml,如图 login_page.yaml文件： username:   dec: 登录页   type: xpath   value: //input[@class='custom-text'] password:   dec: 密码输入框   type: xpath   value: //input[@class='custom-text password']   loginbtn:   dec: 登录按钮   type: xpath  
教你如何写框架------元素管理篇
weixin_30673611的博客
12-03 296
前言： 我的博客从来都是言简意赅，直接步入正题。 元素对象管理： 元素对象（以下称为locator）的维护与管理很麻烦，因为locator比较多，每个页面上要操作的可能有几十个，如何快速的查找及维护好能够使我们写脚本的速度及维护速度大大提升。在前端开发中，开发人员通常是把UI样式放在CSS文件中，受此影响，我们也可以把我们的locator放在一个专门的文件中，按照页面来分类，提取其公共的lo...
数据驱动之Yaml实现
weixin_45589713的博客
09-12 1017
一、背景：数据及配置文件之争 数据及文件通常有三种类型： 配置文件型：如ini，conf，properties文件，适合存储简单变量和配置项，最多支持两层，不适合存储多层嵌套数据 表格矩阵型：如csv，excel等，适合于存储大量同类数据，不适合存储层级结构的数据 多层嵌套型：如XML，HTMl，JSON、YAML，TOML等，适合存储单条或少数多层嵌套数据，不适合存储大量数据 YAML兼容JSON格式，简洁，强大，灵活，可以很方便的构造层级数据并快速转为Python中的字典。 二、YMAL简介 YAML（
Java+Selenium+Testng自动化学习（四）：元素获取及管理
qq_35332549的博客
04-01 876
通过页面元素的固定属性，来确定元素。可以通过id，name，className，tagName，cssSelector，linkText，partialLinkText等属性来定位，不太好定位的元素，可以使用xpath方式。
selenium+pytest:Web自动化Yaml工具类封装（二）
tianheihei__的博客
04-26 1060
web自动化测试框架之元素操作类封装
java+selenium+maven+testng自动化测试框架实例（实际项目）
07-12
java+selenium+maven+testng自动化测试框架实例（实际项目）
基于Selenium的WebUI自动化测试框架（Java+Maven+Selenium+TestNG+Jedis+Jenkins）
05-05
使用Java+Maven+Selenium+TestNG+Jedis+Jenkins搭建的WebUI自动化测试框架，资源的大体介绍如下链接http://note.youdao.com/noteshare?id=dc564343fd126f497074f6d7560c9f5e&sub=387EB3B1BAC945CEA71A5BDBC6484473
selenium+testNG自动化测试框架搭建
02-24
本文来自博客园，本文主要通过配置环境变量以及eclipse中安装testNG插件，希望对您的...系统变量中新建一个变量名称为Java_Home，存放的路径为jdk的安装目录的路径：C:\ProgramFiles\Java\jdk-version新建变量Path：
23种设计模式总结
热门推荐
lgxzzz的博客
05-25 7万+
一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛
自动化测试元素定位“最佳实践”
软件测试技术资源分享官
04-22 188
最近在翻阅cypress文档的时候发现一些关于自动化测试中元素定位的思考，觉得很有意思，这里跟大家分享一下。 核心概念 其实元素定义的核心概念很简单，一些元素总有自己独一无二的一些特点，比如我们每个人都有身份证号，利用这种独特性对元素进行定位，从而进一步做后续操作。 有道是君子有所为有所不为，一些在实践中被证明了是不合适的做法是最好不要去采用的，比如 不要使用有可能发生改变的属性对元素进行定位 。 如果你有能力修改前端代码，那么最佳实践就是: 加一个定位专用的属性，比如 data-* ，这个属性跟js逻辑以
Web元素管理工具（Selenium）
03-15
使用winform管理自动化过程中的页面元素，含建库语句（Sql server），需要在config里面配置数据库连接字符串
最小元素法
05-29
最小元素法，软考部分，分享给大家看看。
2022UI自动化测试框架搭建 —— yaml文件管理定位元素
03-09 4003
介绍 本框架基于Python语言进行开发，使用pytest管理用例运行，使用Jenkins+Allue进行脚本执行与报告展示。 适用于Web、H5、IOS、安卓的UI自动化测试 元素封装 对于一个需要定位的元素，我们一般就需要用到它的描述、定位方式、定位语句、使用时的变量名 由于部分元素出现时间较长，增加一个等待时间 我们编写一个Locator类，来描述一个定位元素 classLocator: """ 页面元素封装 """ def__init__(se...
自动化测试平台(十)：UI自动化元素页面的管理功能实现
曲鸟
01-06 5041
一、前言 上一章我们完成了列表组件公共化封装和项目管理功能的实现，这一章将实现用例概览页功能。 二、初始化数据 表结构模型代码如下： 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
前端权限控制与管理如何写？
丑小鸭变黑天鹅的博客
11-17 226
前端权限控制与管理如何写？一、课程提供的笔记二、自己根据知识点做了一个示例 一、课程提供的笔记 二、自己根据知识点做了一个示例 本示例采用的技术栈为vue+vue-router+vuex+mock.js 有两个用户 管理员，所有权限都有 普通用户，不可以访问商品管理页面，不可以进行添加操作，不可以进行编辑操作 示例截图 1、登录页 2、登录进去的首页 3、用户管理页 总的来说，权限控制就这四个方面，前端控制之后，用户体验会更好，项目会更完美，但
1.UI自动化测试框架搭建-yaml文件管理定位元素
测试游记
03-01 817
介绍本框架基于Python语言进行开发，使用pytest管理用例运行，使用Jenkins+Allue进行脚本执行与报告展示。适用于Web、H5、IOS、安卓的UI自动化测试元素封装对于一个...
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 236
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1348
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 488
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
selenium+java自动化面试题
06-23
Selenium是一款广泛应用于Web应用程序自动化测试的工具，Java是其支持的一种编程语言。在Selenium Java自动化面试...总之，熟练掌握Selenium Java自动化测试工具和相关技术，能够有效提升Web应用程序的测试效率和质量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值