RFT与Spring结合进行自动化脚本开发(1)

RFT与Spring结合进行自动化脚本开发

目前，大部分自动化脚本开发者利用RFT的测试对象地图管理测试脚本的测试对象，RFT的测试对象地图有两种类型：公有测试对象地图和私有测试对象地图。

(1)目前，大部分脚本采用的都是私有测试对象地图，如果被测试的程序顶层对象发生变化，这样每个脚本关联的测试对象地图都要进行修改，之所以这样，有一个原因：在RFT中测试对象地图不能够继承(仅仅可以合并)，如果两个测试对象地图之间可以进行继承，这样把公用的测试对象放在父测试对象地图中，其他的测试对象地图继承这个公用的测试对象地图(同时继承公有的测试对象)，如果被测试程序顶层框架发生变化，仅仅只修改父测试对象地图就可以了，但是目前RFT中不能实现(据我了解)。

(2)RFT中还有一种类型的测试对象地图是公有的测试对象地图，公有的测试对象地图可以实现公用的测试对象重复使用，如果测试对象是一模一样的，RFT在公有的测试对象地图中只保留此测试对象的一个实例，但是把多个测试对象都插入到一个测试对象地图中，同样又面临着难以管理的困难。

(3)另外，RFT中的测试对象地图与脚本紧紧的耦合，如果程序即使发生很小的变动，也要更新测试对象地图，修改脚本等等。

(4)spring具有强大的功能：Ioc,可以实现在xml中把一个测试对象注入到另一个测试对象中，再加上可以利用RFT的find方法可以把spring的配置文件配置成一张RFT测试对象地图。另外，一个spring配置文件可以被另一个spring文件import进来。这样可以把公有的测试对象放在一个spring配置文件中，然后有其他的spring配置文件进行导入，可以实现测试对象地图(spring的配置文件)的继承。另外，在spring的配置文件中，可以注入一个对象的属性，这样可以人工的更改这个测试对象的父框架，另外可以可以注入测试对象的识别属性，这样可以进行人为的进行测试对象识别属性的更改(这样可以更好的应对被测试程序的变化)。
例如：

xml 代码

xml 代码

1.   
2.   
3. <import resource="classpath:pkg/base-test-object-map.xml"/>  
4.   
5.   
6. <property name="objectProperties">  
7.     <list>  
8.           
9.           
10.         <value>.class=Html.FORMvalue>   然后是怎么使用spring配置文件中的测试对象
11.         <value>.name:.*Formvalue>  
12.     list>  
13. property>  
14.            
15.   
16.   
17. <property name="parentTestObject">  
18.     <ref bean="browserTestObject"/>  
19. property>  

在脚本中引用测试对象通过如下语句：

java 代码

1. TextGuiTestObject text_userName = new TextGuiTestObject((TestObject)context.getBean("userNameText"));   
2. text_userName.setText("system");  

 

(5)采用spring管理测试对象，也不是说一劳永逸的，如果被测试程序发生变化，避免不了的也要修改spring配置文件。但是，至少比RFT管理测试对象地图的修改量要小的多。

(6)采用spring管理测试对象也有以下缺点：(1)需要测试脚本开发者有比较高的编程技能(熟悉springIoc基本配置和对RFT API比较熟悉)(2)被测试程序结构规范，最好每个HTML元素都有其名字，还有每次修改程序，如果HTML元素名称能不修改最后就不修改(RFT可以通过组件名称查找对象)还有就是按钮上面的文本，采用RFT管理测试对象地图也有此要求。(3)要求对被测程序的组件结构有充分了解(可以通过RFT测试地图了解)(4)开发采用spring管理测试对象地图的脚本比开发有RFT管理的测试对象地图时间要长的多，但是带来的好处也是明显的。(5)测试对象执行动作的速度也没有RFT管理的测试对象地图快。

base-test-object-map.xml  代码

xml 代码

1. xml version="1.0" encoding="gb2312"?>  
3.     "http://www.springframework.org/dtd/spring-beans.dtd">  
4. <beans>  
5.        
6.       
7.      <bean  id="customEditorConfigurer"  class="org.springframework.beans.factory.config.CustomEditorConfigurer">     
8.         <property name="customEditors">     
9.                 <map>     
10.                     <entry key="com.rational.test.ft.script.Property">  
11.                         <bean class="pkg.TestObjectPropertyEditor"/>  
12.                     entry>     
13.                 map>     
14.         property>     
15.     bean>     
16.   
17.       
18.     <bean id="baseTestObjectScript" class="pkg.BaseTestObjectScript"/>  
19.   
20.       
21.     <bean   id="browserTestObject"  
22.         factory-bean="baseTestObjectScript"  
23.         factory-method="getBrowserTestObject"  
24.         singleton="false"/>  
25.       
26.     <bean   id="documentTestObject"  
27.         factory-bean="baseTestObjectScript"  
28.         factory-method="getDocumentTestObject"  
29.         singleton="false"/>  
30.   
31. beans>  

base-test-object-map.xml  可以作为公有的测试对象地图，其中customEditorConfigurer向容器注册了一个属性编辑，pkg.BaseTestObjectScript是一个RFT脚本，此脚本有getBrowserTestObject()和documentTestObject()，可以在这个类中放入基本的测试对象，通过Spring将这些对象封装为bean, 然后有其他的spring配置文件来import，这样就实现了对象的继承。pkg.BaseTestObjectScript的代码如下：

java 代码

1. package pkg;   
2.   
3. import resources.pkg.BaseTestObjectScriptHelper;   
4.   
5. import com.rational.test.ft.*;   
6. import com.rational.test.ft.object.interfaces.*;   
7. import com.rational.test.ft.object.interfaces.siebel.*;   
8. import com.rational.test.ft.script.*;   
9. import com.rational.test.ft.value.*;   
10. import com.rational.test.ft.vp.*;   
11.   
12. public class BaseTestObjectScript extends BaseTestObjectScriptHelper   
13. {   
14.     public void testMain(Object[] args)    
15.     {   
16.     }   
17.        
18.     public BrowserTestObject getBrowserTestObject()   
19.     {   
20.         return browser_htmlBrowser(document_H(),DEFAULT_FLAGS);   
21.     }   
22.        
23.     public GuiTestObject getDocumentTestObject()   
24.     {   
25.         return document_H();   
26.     }   
27. }  

pkg.TestObjectPropertyEditor代码如下，其中如果用精确匹配就用=作为分隔符，如果是通过正则表达式匹配就通过:作为分隔符，然后在程序内部就会做正则表达式的转换。

java 代码

1. package pkg;   
2.   
3. import com.rational.test.ft.script.Property;   
4. import java.beans.PropertyEditorSupport;     
5. import java.util.StringTokenizer;   
6. import com.rational.test.ft.value.RegularExpression;   
7.   
8. public class TestObjectPropertyEditor extends PropertyEditorSupport   
9. {   
10.     public void setAsText(String text)      
11.     {      
12.         String delimiter = null;   
13.         Object propValue = null;   
14.            
15.         if(text == null || text.length() < 1 || (text.indexOf(EQUAL_MARK) == -1 && text.indexOf(COLON) == -1))   
16.         {   
17.             throw new IllegalArgumentException("识别属性为空或格式不正确 =表示进行精确匹配 :表示使用正则表达式匹配");   
18.         }   
19.            
20.         if(text.indexOf(EQUAL_MARK) != -1)     
21.         {   
22.             delimiter = EQUAL_MARK;   
23.         }   
24.         else if(text.indexOf(COLON) != -1)   
25.         {   
26.             delimiter = COLON;   
27.         }   
28.            
29.         //解析字符串   
30.         StringTokenizer st = new StringTokenizer(text, delimiter);   
31.         String name = st.nextToken();   
32.         String value = st.nextToken();   
33.            
34.         propValue = value;                 
35.            
36.         if(text.indexOf(COLON) != -1)   //如果分隔符为 : 将propValue设置为正则表达式   
37.         {   
38.             propValue = new RegularExpression(value, false);   
39.         }   
40.         setValue(new Property(name, propValue));   
41.     }      
42.           
43.     public String getAsText()      
44.     {      
45.         Property property = (Property)getValue();   
46.         return property.getPropertyName() + "-" + property.getPropertyValue();   
47.     }      
48.        
49.     public final String EQUAL_MARK = "=";       //"=" 表示进行精确匹配   
50.     public final String COLON = ":";            //":" 表示使用正则表达式匹配   
51. }   

然后介绍一下其他的Spring配置文件通过导入另一个Spring配置文件实现，测试对象的继承。如下，通过import另一个配置文件，这个spring配置文件中的对象就可以使用被导入的spring配置文件中的测试对象，从而可以实现测试对象的继承。

pkg/logon-map.xml

xml 代码

1. xml version="1.0" encoding="gb2312"?>  
3.     "http://www.springframework.org/dtd/spring-beans.dtd">  
4. <beans>  
5.   
6.       
7.       
8.     <import resource="classpath:pkg/base-test-object-map.xml"/>  
9.         
10.       
11.     <bean   id="loginFormHelper"    
12.         class="pkg.TestObjectHelper"  
13.         singleton="false">  
14.   
15.           
16.         <property name="objectProperties">  
17.             <list>  
18.                   
19.                   
20.                 <value>.class=Html.FORMvalue>  
21.                 <value>.name:.*Formvalue>  
22.             list>  
23.         property>  
24.            
25.           
26.           
27.         <property name="parentTestObject">  
28.             <ref bean="browserTestObject"/>  
29.         property>  
30.     bean>  
31.   
32.       
33.     <bean   id="loginForm"  
34.         factory-bean="loginFormHelper"  
35.         factory-method="getSonTestObject"  
36.         singleton="false">  
37.     bean>  
38.        
39.       
40.     <bean   id="userNameTextHelper"  
41.         class="pkg.TestObjectHelper"  
42.         singleton="false">  
43.         <property name="objectProperties">  
44.             <list>  
45.                 <value>.class=Html.INPUT.textvalue>  
46.                 <value>.name=userNamevalue>  
47.             list>  
48.         property>  
49.   
50.         <property name="parentTestObject">  
51.             <ref bean="loginForm"/>  
52.         property>  
53.     bean>  
54.   
55.       
56.     <bean   id="userNameText"  
57.         factory-bean="userNameTextHelper"  
58.         factory-method="getSonTestObject"  
59.         singleton="false">  
60.     bean>  
61.   
62.     <bean   id="passwordTextHelper"  
63.         class="pkg.TestObjectHelper"  
64.         singleton="false">  
65.         <property name="objectProperties">  
66.             <list>  
67.                 <value>.class=Html.INPUT.passwordvalue>  
68.                 <value>.name=passWordvalue>  
69.             list>  
70.         property>  
71.   
72.         <property name="parentTestObject">  
73.             <ref bean="loginForm"/>  
74.         property>  
75.     bean>  
76.   
77.     <bean   id="passwordText"  
78.         factory-bean="passwordTextHelper"  
79.         factory-method="getSonTestObject"  
80.         singleton="false">  
81.     bean>  
82.   
83.       
84.     <bean   id="submitButtonHelper"  
85.         class="pkg.TestObjectHelper"  
86.         singleton="false">  
87.         <property name="objectProperties">  
88.             <list>  
89.                 <value>.class=Html.INPUT.submitvalue>  
90.                 <value>.value=进入value>  
91.             list>  
92.         property>  
93.   
94.         <property name="parentTestObject">  
95.             <ref bean="loginForm"/>  
96.         property>  
97.     bean>  
98.   
99.     <bean   id="submitButton"  
100.         factory-bean="submitButtonHelper"  
101.         factory-method="getSonTestObject"  
102.         singleton="false">  
103.     bean>  
104.   
105.       
106.     <bean   id="menuHelper"  
107.         class="pkg.MenuHelper"  
108.         singleton="false">  
109.   
110.           
111.         <property name="menus">  
112.             <list>  
113.                 <value>菜单名称1value>  
114.                 <value>菜单名称2value>  
115.                 <value>菜单名称3value>  
116.                 <value>菜单名称4value>  
117.             list>  
118.         property>  
119.            
120.           
121.         <property name="parentTestObject">  
122.             <ref bean="documentTestObject"/>  
123.         property>  
124.     bean>  
125.   
126. beans>  

下面是上面的配置文件中用到的pkg.TestObjectHelper类，这个类暴露出parentTestObject 和 objectProperties两个属性用spring来注入，从而确定从什么对象开始查找对象和以什么条件查找对象。通过getSonTestObject() 方法返回找到的测试对象(只允许返回一个对象，如果找到多个就会抛出异常)，其中还有个getSonTestObjects()方法是为了返回多个测试对象而准备的。代码如下：