提出问题

如何优雅编写测试代码？？？

解决问题

1）TDD（测试驱动开发），意思是先写单元测试，然后写对应的代码，通过修改调试让写的代码通过单元测试。使用TDD，会使测试覆盖所有的代码，测试代码和生产代码的比例有可能会达到1:1 ，所以也会带来成本的问题，所有我们要保持测试的整洁。

2）单元测试的好处：让代码可扩展，可维护，可复用。

3）整洁测试的三要素 ：可读性、可读性、可读性。

4）每个测试都可以拆分为三个环节：构造测试数据、操作测试数据、检验操作是否达到预期结果。

5）双重标准：测试环境中和生产环境中有些条件不必完全一致。生产环境中有时要考虑内存、CPU等性能问题，而在测试环境中不必做这些限制。

6)一个测试一个断言，不必完全纠结，但单个测试断言数应该最小化，只测试一个概念，还是单一职责的问题；

7）F.I.R.S.T原则

F Fast:测试需要频繁运行，因此要能快速运行；

I Independent：测试应该相互独立；

R Repeatable：测试应当能在任何环境中重复；

S Self-validating：自足验证，测试应该能看到成功与否的结果；

T Timely：测试应该及时编写，应该恰好在生产代码之前编写；

package com.hwy.test;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
public class CodeCleanTest {
    @Test
    public void testBuySnacks(){
        List<String> snacks =  buySnacks();
        Assert.assertEquals("购买零食有问题，请检查!!!",true,snacks.size()>0);
    }
    @Test
    public void testEatSnacks(){
        /** 这个是我们自己构建的零食数据，肯定不会出现null等问题 **/
        /** 我们不要调用buySnacks方法，因为还是单一职责的问题，只测试一个概念**/
        List<String> snacks =  getSnacks();
        Assert.assertEquals("没有一起吃3个零食", 3, eatSnacks(snacks));
    }
    @Test
    public void testDropLitter(){
        List<String> snacks =  getSnacks();
        Assert.assertEquals("垃圾没有扔掉!!!",true,dropLitter(snacks));
    }
    @Test
    public void testDateWithGirl() throws Exception{
        Assert.assertEquals("约会失败了", true, dateWithGirl());
    }
    /**
     * 构建零食数据(事实这些注释都是不需要，只是为了大家理解)
     * @return
     */
    public List<String> getSnacks(){
        List<String> snacksList = new ArrayList<>();
        snacksList.add("牛奶");
        snacksList.add("巧克力");
        snacksList.add("土豆片");
        return snacksList;
    }
    /**
     * 买零食(事实这些注释都是不需要，只是为了大家理解)
     * @return
     */
    public List<String> buySnacks(){
        List<String> snacksList = new ArrayList<>();
        snacksList.add("牛奶");
        snacksList.add("巧克力");
        snacksList.add("土豆片");
        /** 这里故意显示为空 **/
        //return null;
        return snacksList;
    }
    /**
     * 约会
     */
    public boolean dateWithGirl() throws Exception {
        boolean isSuccess = false;
        List<String> snacksList =  buySnacks();
        /** 利用逆向思维，抛出一个业务异常，这里我只是用简单的exception代替 **/
        if(null == snacksList || snacksList.size() ==0){
            throw new Exception("你没买到零食或买到的零食有问题，请检查！");
        }
        /** 代码执行到这一步就说明snacksList不为null，之后的所有
         * 操作都不用判断snacksList是否为空 **/
        List<String> litter =  eatSnacks(snacksList);
        dropLitter(litter);
        isSuccess = true;
        return isSuccess;
    }
    /**
     * 吃零食(事实这些注释都是不需要，只是为了大家理解)
     * @param snacks
     */
    public List<String> eatSnacks(List<String> snacks){
        for (String snack : snacks) {
            System.out.println("一起吃" + snack);
        }
        return snacks;
    }
    /**
     * 仍垃圾(事实这些注释都是不需要，只是为了大家理解)
     * @param litter
     */
    public boolean dropLitter(List<String> litter){
        boolean isDrop = false;
        for(String snack:litter){
            System.out.println("扔掉垃圾:" + snack);
        }
        /** 这里故意写的有点冗余，只是方便大家学习 **/
        isDrop = true;
        return isDrop;
    }
}

上面的每个测试方法都是：test + 原方法名称，一般测试方法都是这么命名的。同时上面的测试方法，没给方法都是独立的，只测试一个概念。

下面举一个错误的实例：

package com.hwy.test;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
public class CodeCleanTest {
   @Test
   public void testBuySnacks() throws Exception{
       /** 像这样子，在一个测试方法中，测试太多的方法，造成测试用例难以复用 **/
       /** 这样不符合每个测试一个断言的规则，同时也不符合F.I.R.S.T原则**/
       List<String> snacks =  buySnacks();
       Assert.assertEquals("购买零食有问题，请检查!!!",true,snacks.size()>0);
       Assert.assertEquals("没有一起吃3个零食", 3, eatSnacks(snacks));
       Assert.assertEquals("垃圾没有扔掉!!!",true,dropLitter(snacks));
       Assert.assertEquals("约会失败了", true, dateWithGirl());
   }
   /**
    * 构建零食数据(事实这些注释都是不需要，只是为了大家理解)
    * @return
    */
   public List<String> getSnacks(){
       List<String> snacksList = new ArrayList<>();
       snacksList.add("牛奶");
       snacksList.add("巧克力");
       snacksList.add("土豆片");
       return snacksList;
   }
   /**
    * 买零食(事实这些注释都是不需要，只是为了大家理解)
    * @return
    */
   public List<String> buySnacks(){
       List<String> snacksList = new ArrayList<>();
       snacksList.add("牛奶");
       snacksList.add("巧克力");
       snacksList.add("土豆片");
       /** 这里故意显示为空 **/
       //return null;
       return snacksList;
   }
   /**
    * 约会
    */
   public boolean dateWithGirl() throws Exception {
       boolean isSuccess = false;
       List<String> snacksList =  buySnacks();
       /** 利用逆向思维，抛出一个业务异常，这里我只是用简单的exception代替 **/
       if(null == snacksList || snacksList.size() ==0){
           throw new Exception("你没买到零食或买到的零食有问题，请检查！");
       }
       /** 代码执行到这一步就说明snacksList不为null，之后的所有
        * 操作都不用判断snacksList是否为空 **/
       List<String> litter =  eatSnacks(snacksList);
       dropLitter(litter);
       isSuccess = true;
       return isSuccess;
   }
   /**
    * 吃零食(事实这些注释都是不需要，只是为了大家理解)
    * @param snacks
    */
   public List<String> eatSnacks(List<String> snacks){
       for (String snack : snacks) {
           System.out.println("一起吃" + snack);
       }
       return snacks;
   }
   /**
    * 仍垃圾(事实这些注释都是不需要，只是为了大家理解)
    * @param litter
    */
   public boolean dropLitter(List<String> litter){
       boolean isDrop = false;
       for(String snack:litter){
           System.out.println("扔掉垃圾:" + snack);
       }
       /** 这里故意写的有点冗余，只是方便大家学习 **/
       isDrop = true;
       return isDrop;
   }
}