越来越觉得自己走测试这条路是对的，越来越觉得自己适合做测试，这么久以来兴趣一直在激发我前进，一直在寻找下一个站点，我相信测试路上我一定会走的很远，我的测试道路一定会很宽阔，努力就有收获，也希望还在测试路口迷惘的朋友，不要再犹豫了，因为你的犹豫不决，会使你错过很多~~~~~喜欢就去just do it ，因为只有尝试了才知道自己适不适合，喜不喜欢。如果一味的问别人，永远找不到最终的答案。因为每个人的感觉不一样，每个人的情况不一样，每个人的前提条件都不一样，你会得到不同的答案，这样只能会使你更迷茫~~~~

HttpUnit

上一篇 / 下一篇  2010-02-01 14:47:28 / 个人分类：测试相关资料

查看( 7646 ) / 评论( 2 ) / 评分( 0 / 0 )

HttpUnit是一个集成测试工具，主要关注Web应用的测试，提供的帮助类让测试者可以通过Java类和服务器进行交互，并且将服务器端的响应当作文本或者DOM对象进行处理。HttpUnit还提供了一个模拟Servlet容器，让你可以不需要发布Servlet，就可以对Servlet的内部代码进行测试。本文中作者将详细的介绍如何使用HttpUnit提供的类完成集成测试。

1. 如何使用httpunit处理页面的内容

  • WebConversation类是HttpUnit框架中最重要的类，它用于模拟浏览器的行为
  • WebRequest类，模仿客户请求，通过它可以向服务器发送信息
  • WebResponse类，模拟浏览器获取服务器端的响应信息

1.1 获取指定页面的内容
   1.1.1 直接获取页面内容

java 代码
  1. System.out.println("直接获取网页内容：");   
  2. //建立一个WebConversation实例  
  3. WebConversation wc = new WebConversation();   
  4. //向指定的URL发出请求，获取响应  
  5. WebResponse wr = wc.getResponse( "http://localhost:6888/HelloWorld.html" );   
  6. //用getText方法获取相应的全部内容  
  7. //用System.out.println将获取的内容打印在控制台上  
  8. System.out.println( wr.getText() );  

 1.1.2 通过Get方法访问页面并且加入参数

java 代码
  1. System.out.println("向服务器发送数据，然后获取网页内容：");   
  2. //建立一个WebConversation实例  
  3. WebConversation wc = new WebConversation();   
  4. //向指定的URL发出请求  
  5. WebRequest req = new GetMethodWebRequest( "http://localhost:6888/HelloWorld.jsp" );   
  6. //给请求加上参数    
  7. req.setParameter("username","姓名");   
  8. //获取响应对象  
  9. WebResponse resp = wc.getResponse( req );   
  10. //用getText方法获取相应的全部内容  
  11. //用System.out.println将获取的内容打印在控制台上  
  12. System.out.println( resp.getText() );  

1.1.3 通过Post方法访问页面并且加入参数

java 代码
  1. System.out.println("使用Post方式向服务器发送数据，然后获取网页内容：");   
  2. //建立一个WebConversation实例  
  3. WebConversation wc = new WebConversation();   
  4. //向指定的URL发出请求  
  5. WebRequest req = new PostMethodWebRequest( "http://localhost:6888/HelloWorld.jsp" );   
  6. //给请求加上参数    
  7. req.setParameter("username","姓名");   
  8. //获取响应对象  
  9. WebResponse resp = wc.getResponse( req );   
  10.   
  11. //用getText方法获取相应的全部内容  
  12. //用System.out.println将获取的内容打印在控制台上  
  13. System.out.println( resp.getText() );  

大家关注一下上面代码中打了下划线的两处内容，应该可以看到，使用Get、Post方法访问页面的区别就是使用的请求对象不同。

1.2 处理页面中的链接
这里的演示是找到页面中的某一个链接，然后模拟用户的单机行为，获得它指向文件的内容。比如在我的页面HelloWorld.html中有一个链接，它显示的内容是TestLink，它指向我另一个页面TestLink.htm. TestLink.htm里面只显示TestLink.html几个字符。
下面是处理代码：

java 代码
  1. System.out.println("获取页面中链接指向页面的内容：");   
  2. //建立一个WebConversation实例  
  3. WebConversation wc = new WebConversation();   
  4. //获取响应对象  
  5. WebResponse resp = wc.getResponse( "http://localhost:6888/HelloWorld.html" );   
  6. //获得页面链接对象  
  7. WebLink link = resp.getLinkWith( "TestLink" );   
  8. //模拟用户单击事件   
  9. link.click();   
  10. //获得当前的响应对象  
  11. WebResponse  nextLink = wc.getCurrentPage();   
  12.   
  13. //用getText方法获取相应的全部内容  
  14. //用System.out.println将获取的内容打印在控制台上  
  15. System.out.println( nextLink.getText() );  

1.3 处理页面中的表格
表格是用来控制页面显示的常规对象，在HttpUnit中使用数组来处理页面中的多个表格，你可以用resp.getTables()方法获取页面所有的表格对象。他们依照出现在页面中的顺序保存在一个数组里面。

[注意] Java中数组下标是从0开始的，所以取第一个表格应该是resp.getTables()[0]，其他以此类推。

下面的例子演示如何从页面中取出第一个表格的内容并且将他们循环显示出来：

java 代码
  1. System.out.println("获取页面中表格的内容;");   
  2. //建立一个WebConversation实例  
  3. WebConversation wc = new WebConversation();   
  4. //获取响应对象  
  5. WebResponse   resp = wc.getResponse( "http://localhost:6888/HelloWorld.html" );   
  6. //获得对应的表格对象  
  7. WebTable webTable = resp.getTables()[0];   
  8. //将表格对象的内容传递给字符串数组  
  9. String[][] datas = webTable.asText();   
  10. //循环显示表格内容  
  11. int i = 0 ,j = 0;   
  12. int m = datas[0].length;   
  13. int n = datas.length;   
  14. while (i
  15.   j=0;   
  16.   while(j
  17.     System.out.println("表格中第"+(i+1)+"行第"+   
  18.  (j+1)+"列的内容是："+datas[i][j]);   
  19.     ++j;   
  20.   }   
  21.   ++i;   
  22. }  

1.4 处理页面中的表单
表单是用来接受用户输入，也可以向用户显示用户已输入信息（如需要用户修改数据时，通常会显示他以前输入过的信息），在HttpUnit中使用数组来处理页面中的多个表单，你可以用resp.getForms()方法获取页面所有的表单对象。他们依照出现在页面中的顺序保存在一个数组里面。

[注意] Java中数组下标是从0开始的，所以取第一个表单应该是resp.getForms()[0]，其他以此类推。

下面的例子演示如何从页面中取出第一个表单的内容并且将他们循环显示出来：

java 代码
  1. System.out.println("获取页面中表单的内容：");   
  2. //建立一个WebConversation实例  
  3. WebConversation wc = new WebConversation();   
  4. //获取响应对象  
  5. WebResponse resp = wc.getResponse( "http://localhost:6888/HelloWorld.html" );   
  6. //获得对应的表单对象  
  7. WebForm webForm = resp.getForms()[0];   
  8. //获得表单中所有控件的名字  
  9. String[] pNames = webForm.getParameterNames();   
  10. int i = 0;   
  11. int m = pNames.length;   
  12. //循环显示表单中所有控件的内容  
  13. while(i
  14.    System.out.println("第"+(i+1)+"个控件的名字是"+pNames[i]+   
  15.    "，里面的内容是"+webForm.getParameterValue(pNames[i]));   
  16.    ++i;   
  17. }  

2. 如何使用httpunit进行测试
2.1 对页面内容进行测试
httpunit中的这部分测试完全采用了JUnit的测试方法，即直接将你期望的结果和页面中的输出内容进行比较。不过这里的测试就简单多了，只是字符串和字符串的比较。

比如你期望中的页面显示是中有一个表格，它是页面中的第一个表格，而且他的第一行第一列的数据应该是显示username，那么你可以使用下面的代码进行自动化测试：

java 代码
  1. System.out.println("获取页面中表格的内容并且进行测试：");   
  2. //建立一个WebConversation实例  
  3. WebConversation wc = new WebConversation();   
  4. //获取响应对象  
  5. WebResponse resp = wc.getResponse( "http://localhost:6888/TableTest.html" );   
  6. //获得对应的表格对象  
  7. WebTable webTable = resp.getTables()[0];   
  8. //将表格对象的内容传递给字符串数组  
  9. String[][] datas = webTable.asText();   
  10. //对表格内容进行测试  
  11. String expect = "中文";   
  12. Assert.assertEquals(expect,datas[0][0]);  

2.2 对Servlet进行测试
除了对页面内容进行测试外，有时候（比如开发复杂的Servlets的时候），你需要对Servlet本身的代码块进行测试，这时候你可以选择HttpUnit，它可以提供一个模拟的Servlet容器，让你的Servlet代码不需要发布到Servlet容器（如tomcat）就可以直接测试。

2.2.1 原理简介
使用httpunit测试Servlet时，请创建一个ServletRunner的实例，他负责模拟Servlet容器环境。如果你只是测试一个Servlet,你可以直接使用registerServlet方法注册这个Servlet，如果需要配置多个Servlet，你可以编写自己的web.xml，然后在初始化ServletRunner的时候将它的位置作为参数传给ServletRunner的构造器。

在测试Servlet时，应该记得使用ServletUnitClient类作为客户端，他和前面用过的WebConversation差不多，都继承自WebClient，所以他们的调用方式基本一致。要注意的差别是，在使用ServletUnitClient时，他会忽略URL中的主机地址信息，而是直接指向他的ServletRunner实现的模拟环境。

2.2.2 简单测试
本实例只是演示如何简单的访问Servlet并且获取他的输出信息，例子中的Servlet在接到用户请求的时候只是返回一串简单的字符串：Hello World!.

1. Servlet的代码如下：

java 代码
  1. package janier.servlet;   
  2.   
  3. import java.io.IOException;   
  4. import java.io.PrintWriter;   
  5.   
  6. import javax.servlet.http.HttpServlet;   
  7. import javax.servlet.http.HttpServletRequest;   
  8. import javax.servlet.http.HttpServletResponse;   
  9.   
  10. /** 
  11.  * @author Janier 
  12.  * 
  13.  */  
  14. public class HelloWorld extends HttpServlet {   
  15.      /** 
  16.      *  
  17.      */  
  18.     private static final long serialVersionUID = 7242188527423883719L;   
  19.   
  20.     public void service(HttpServletRequest req, HttpServletResponse resp)   
  21.      throws IOException   
  22.      {   
  23.       PrintWriter out = resp.getWriter();   
  24.       //向浏览器中写一个字符串Hello World!  
  25.       out.println("Hello World!");   
  26.       out.close();   
  27.      }   
  28. }  

 2. 测试的调用代码如下：

java 代码
  1. package test.servlet;   
  2.   
  3. import janier.servlet.HelloWorld;   
  4.   
  5. import com.meterware.httpunit.GetMethodWebRequest;   
  6. import com.meterware.httpunit.WebRequest;   
  7. import com.meterware.httpunit.WebResponse;   
  8. import com.meterware.servletunit.ServletRunner;   
  9. import com.meterware.servletunit.ServletUnitClient;   
  10.   
  11. import junit.framework.TestCase;   
  12.   
  13. /** 
  14.  * @author Janier 
  15.  * 
  16.  */  
  17. public class HttpUnitTestHelloWorld extends TestCase{   
  18.        
  19.     protected void setUp() throws Exception {   
  20.           super.setUp();   
  21.          }   
  22.             
  23.          protected void tearDown() throws Exception {   
  24.           super.tearDown();   
  25.          }   
  26.             
  27.          public void testHelloWorld() {   
  28.              
  29.           try {   
  30.               //创建Servlet的运行环境  
  31.               ServletRunner sr = new ServletRunner();   
  32.               //向环境中注册Servlet  
  33.               sr.registerServlet( "HelloWorld", HelloWorld.class.getName() );   
  34.               //创建访问Servlet的客户端  
  35.               ServletUnitClient sc = sr.newClient();   
  36.               //发送请求  
  37.               WebRequest request = new GetMethodWebRequest( "http://localhost/HelloWorld" );   
  38.               //获得模拟服务器的信息  
  39.               WebResponse response = sc.getResponse( request );   
  40.               //将获得的结果打印到控制台上  
  41.               System.out.println(response.getText());   
  42.           } catch (Exception e) {   
  43.            e.printStackTrace();   
  44.            }   
  45.           }   
  46. }  

2.2 测试Servlet的内部行为
下面的代码演示了如何使用HttpUnit模拟Servlet容器，并且通过InvocationContext对象，测试Servlet内部行为的大部分工作，比如控制request、session、response等。

1.测试代码

java 代码
  1. package test.servlet;   
  2.   
  3. import janier.servlet.HelloWorld;   
  4.   
  5. import com.meterware.httpunit.GetMethodWebRequest;   
  6. import com.meterware.httpunit.WebRequest;   
  7. import com.meterware.httpunit.WebResponse;   
  8. import com.meterware.servletunit.InvocationContext;   
  9. import com.meterware.servletunit.ServletRunner;   
  10. import com.meterware.servletunit.ServletUnitClient;   
  11.   
  12. import junit.framework.Assert;   
  13. import junit.framework.TestCase;   
  14.   
  15. /** 
  16.  * @author Janier 
  17.  * 
  18.  */  
  19. public class HttpUnitTestHelloWorld extends TestCase{   
  20.        
  21.     protected void setUp() throws Exception {   
  22.           super.setUp();   
  23.          }   
  24.             
  25.          protected void tearDown() throws Exception {   
  26.           super.tearDown();   
  27.          }   
  28.             
  29.          public void testHelloWorld() {   
  30.              
  31.           try {   
  32.               // 创建Servlet的运行环境  
  33.               ServletRunner sr = new ServletRunner();   
  34.               //向环境中注册Servlet  
  35.               sr.registerServlet( "HelloWorld", HelloWorld.class.getName() );   
  36.               //创建访问Servlet的客户端  
  37.               ServletUnitClient sc = sr.newClient();   
  38.               //发送请求  
  39.               WebRequest request = new GetMethodWebRequest( "http://localhost/HelloWorld" );   
  40.               request.setParameter("username","testuser");   
  41.               //获得该请求的上下文环境  
  42.               InvocationContext ic = sc.newInvocation( request );         
  43.               //调用Servlet的非服务方法  
  44.               HelloWorld is = (HelloWorld)ic.getServlet();   
  45.               //测试servlet的某个方法  
  46.                Assert.assertTrue(is.authenticate());   
  47.               //直接通过上下文获得request对象  
  48.               System.out.println("request中获取的内容："+ic.getRequest().getParameter("username"));   
  49.               //直接通过上下文获得response对象,并且向客户端输出信息  
  50.               ic.getResponse().getWriter().write("haha");   
  51.               //直接通过上下文获得session对象，控制session对象,给session赋值  
  52.               ic.getRequest().getSession().setAttribute("username","timeson");   
  53.               //获取session的值  
  54.               System.out.println("session中的值："+ic.getRequest().getSession().getAttribute("username"));   
  55.               //使用客户端获取返回信息，并且打印出来  
  56.               WebResponse response = ic.getServletResponse();   
  57.               System.out.println(response.getText());   
  58.           } catch (Exception e) {   
  59.            e.printStackTrace();   
  60.            }   
  61.           }   
  62. }  

2.调用代码

java 代码
  1. package janier.servlet;   
  2.   
  3. import java.io.IOException;   
  4.   
  5. import javax.servlet.http.HttpServlet;   
  6. import javax.servlet.http.HttpServletRequest;   
  7. import javax.servlet.http.HttpServletResponse;   
  8.   
  9. /** 
  10.  * @author Janier 
  11.  * 
  12.  */  
  13. public class HelloWorld extends HttpServlet {   
  14. public void saveToSession(HttpServletRequest request) {   
  15.         request.getSession().setAttribute("testAttribute",request.getParameter("testparam"));   
  16.         }   
  17.     public void doGet(HttpServletRequest request,   
  18.         HttpServletResponse response) throws IOException{   
  19.         String username=request.getParameter("username");   
  20.         response.getWriter().write(username+":Hello World!");   
  21.         }   
  22.     public boolean authenticate(){   
  23.        return true;   
  24.        }   
  25. }  

对于开发者来说，仅仅测试请求和返回信息是不够的，所以HttpUnit提供的ServletRunner模拟器可以让你对被调用Servlet内部的行为进行测试。和简单测试中不同，这里使用了InvocationContext获得该Servlet的环境，然后你可以通过InvocationContext对象针对request、response等对象或者是该Servlet的内部行为（非服务方法）进行操作。

上述例子其实是junit的一个测试例子，在其中使用了httpunit模拟的servlet环境,使用上述方法测试servlet可以脱离容器，容易把该测试写入ant或maven脚本，让测试进行。httpunit网址：http://httpunit.sourceforge.net/
使用该种方法测试的弱点就是：如果要使用request(response)的setCharercterEncoding方法时，测试会出现一些问题,而且httpunit在测试servlet行为时，采用的是完全模拟浏览器，有时测试比较难写。

[注意]在测试Servlet的之前，你必须通过InvocationContext完成Servlet中的service方法中完成的工作，因为通过newInvocation方法获取InvocationContext实例的时候该方法并没有被调用。

3. Httpunit测试小总结

  1. 模拟用户行为向服务器发送请求，传递参数
  2. 模拟用户接受服务器的响应信息，并且通过辅助类分析这些响应信息，结合JUnit框架进行测试
  3. 使用HttpUnit提供的模拟Servler容器,测试开发中的Servlet的内部行为

Mock objects方法的最大优点就是，执行测试时不需要运行的容器。可以很快就建立起测试，而且测试运行速度也很快用mock objects来对J2EE组件进行单元测试的缺点是：

  • 它们没有测试容器和组件的交互;
  • 它们没有测试组件的部署部分;
  •  需要熟悉被调用的API，这样才能模拟它，而这个要求可能太高了（尤其对于外部库而言）;
  • 无法让你确信代码会在目标容器中正常运行

收藏 举报

TAG:

享受测试带来的一切 引用 删除 月上百合   /   2010-02-02 15:03:28
原帖由smile665于2010-02-01 16:34:47发表
有点技术性了哦，原创的吗？~  还没完全看懂呢

不是原创，来自网络
笑遍世界的测试技术 引用 删除 smile665   /   2010-02-01 16:34:47
有点技术性了哦，原创的吗？~  还没完全看懂呢
 

评分：0

我来说两句

Open Toolbar