大家好，又见面了，我是你们的朋友全栈君。

原文地址：https://www.jianshu.com/p/72b19e24a602

前言

mac上idea快捷键，command+shift+T根据类生成快捷键。

对spring容器中的类做单元测试

在src/main下建立UserService类，对其进行单于测试，生产其单元测试类（使用command+shift+T快捷键）,生成的test类在src/test下

@Service
public class UserService {

    public Integer addUser(String username){
        System.out.println("user dao adduser [username="+username+"]");
        if(username == null){
            return 0;
        }
        return 1;
    }
}

springboot启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void addUser() throws Exception {
        Assert.assertEquals(Integer.valueOf(1),userService.addUser("zhihao.miao"));
        Assert.assertEquals(Integer.valueOf(0),userService.addUser(null));
    }

}

盲点扫描

RunWith注解，SpringRunner类，SpringJUnit4ClassRunner类，SpringBootTest注解的解释。

RunWith注解

When a class is annotated with @RunWith or extends a class annotated with @RunWith, JUnit will invoke the class it references to run the tests in that class instead of the runner built into JUnit. We added this feature late in development. While it seems powerful we expect the runner API to change as we learn how people really use it. Some of the classes that are currently internal will likely be refined and become public.
当一个类用@RunWith注释或继承一个用@RunWith注释的类时，JUnit将调用它所引用的类来运行该类中的测试而不是开发者去在junit内部去构建它。我们在开发过程中使用这个特性。

For example, suites in JUnit 4 are built using RunWith, and a custom runner named Suite:
比如说，suites使用RunWith注解构建，

@RunWith(Suite.class)
@SuiteClasses({ATest.class, BTest.class, CTest.class})
public class ABCSuite {
}

SpringRunner注解

SpringRunner is an alias for the SpringJUnit4ClassRunner.
SpringRunner是SpringJUnit4ClassRunner的一个别名。

To use this class, simply annotate a JUnit 4 based test class with @RunWith(SpringRunner.class).
使用这个类，简单注解一个JUnit 4 依赖的测试@RunWith(SpringRunner.class).

If you would like to use the Spring TestContext Framework with a runner other than
this one, use org.springframework.test.context.junit4.rules.SpringClassRule
and org.springframework.test.context.junit4.rules.SpringMethodRule.
如果你想使用Spring测试上下文而不是使用这个，你可以使用org.springframework.test.context.junit4.rules.SpringClassRule和org.springframework.test.context.junit4.rules.SpringMethodRule.

SpringJUnit4ClassRunner

SpringJUnit4ClassRunner is a custom extension of JUnit’s
BlockJUnit4ClassRunner which provides functionality of the
Spring TestContext Framework to standard JUnit tests by means of the
TestContextManager and associated support classes and annotations.
SpringJUnit4ClassRunner是JUnit’s的BlockJUnit4ClassRunner类的一个常规扩展，提供了一些spring测试环境上下文去规范JUnit测试，意味着TestContextManager和支持相关的类和注解。

SpringBootTest注解

Annotation that can be specified on a test class that runs Spring Boot based tests.
Provides the following features over and above the regular Spring TestContext
Framework:
注解制定了一个测试类运行了Spring Boot环境。提供了以下一些特性：

Uses SpringBootContextLoader as the default ContextLoader when no specific ContextConfiguration#loader() @ContextConfiguration(loader=…) is defined.
当没有特定的ContextConfiguration#loader()（@ContextConfiguration(loader=…)）被定义那么就是SpringBootContextLoader作为默认的ContextLoader。

Automatically searches for a SpringBootConfiguration @SpringBootConfiguration when nested @Configuration is not used, and no explicit #classes() classes are
specified.
自动搜索到SpringBootConfiguration注解的文件。

Allows custom Environment properties to be defined using the properties() properties attribute}.
允许自动注入Environment类读取配置文件。

Provides support for different #webEnvironment() webEnvironment modes,
including the ability to start a fully running container listening on a
WebEnvironment#DEFINED_PORT defined or WebEnvironment#RANDOM_PORT
random port.
提供一个webEnvironment环境，可以完整的允许一个web环境使用随机的端口或者自定义的端口。

Registers a org.springframework.boot.test.web.client.TestRestTemplate
TestRestTemplate bean for use in web tests that are using a fully running container.
注册了TestRestTemplate类可以去做接口调用。

springboot测试步骤

• 直接在测试类上面加上如下2个注解
  @RunWith(SpringRunner.class)
  @SpringBootTest
  就能取到spring中的容器的实例，如果配置了@Autowired那么就自动将对象注入。

在测试环境中获取一个bean，在项目中新建User类，然后在测试模块进行测试

在src/main下新建一个实例User

@Component
public class User {
}

src/test下创建测试类测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserTest {


    @Autowired
    public ApplicationContext context;

    @Test
    public void testNotNull(){
        Assert.assertNotNull(context.getBean(User.class));
    }
}

只在测试环境有效的bean

在src/test下新建二个类，我们发现分别使用@TestComponent和@TestConfiguration二个注解修饰，这些类只在测试环境生效

@TestComponent
public class Cat {

    public void index(){
        System.out.println("cat index");
    }
}

@TestConfiguration
public class TestBeanConfiguration {

    @Bean
    public Runnable createRunnable(){
        return () -> System.out.println("=====createRunnable=======");
    }
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {TestBeanConfiguration.class,Cat.class})
public class TestApplication {

    @Autowired
    public ApplicationContext context;

    @Test
    public void testNotNull(){
        Runnable runnable = context.getBean(Runnable.class);
        runnable.run();
        System.out.println("--------");

        Cat cat = context.getBean(Cat.class);
        cat.index();
    }
}

需要在@SpringBootTest注解的参数classes中加入参数，表示将某些类纳入测试环境的容器中。

TestComponent注解

TestConfiguration注解

配置文件属性的读取

springboot会只会读取到src/test/resources下的配置，不会读到正式环境下的配置文件(跟以前1.4.*版本的不一样，以前是优先读取测试环境配置文件，然后读取正式环境的配置）

@RunWith(SpringRunner.class)
@SpringBootTest
public class EnvTest {

    @Autowired
    public Environment environment;

    @Test
    public void testValue(){
        Assert.assertEquals("zhihao.miao",environment.getProperty("developer.name"));

    }
}

除了在配置文件中设置属性，测试环境加载一些配置信息的二种方式：
第一种是使用@SpringBootTest注解，注解参数properties指定其value值，第二种使用EnvironmentTestUtils.addEnvironment方法进行设置。
测试：

@RunWith(SpringRunner.class)
@SpringBootTest(properties = {"app.version=1.0"})
public class EnvTest2 {

    @Autowired
    private ConfigurableEnvironment environment;

    @Before
    public void init(){
        EnvironmentTestUtils.addEnvironment(environment,"app.admin.user=zhangsan");
    }

    @Test
    public void testApplication(){
        Assert.assertEquals("1.0",environment.getProperty("app.version"));
        Assert.assertEquals("zhangsan",environment.getProperty("app.admin.user"));
    }
}

Mock方式的测试

正式环境只是一个接口，并没有实现，也并没有纳入spring容器进行管理。

public interface UserDao {
    Integer createUser(String userName);
}

测试

@RunWith(SpringRunner.class)
public class UserDaoTest {

    //使用MockBean是因为此时容器中没有UserMapper这个对象
    @MockBean
    public UserDao userDao;

    //使用BDDMockito对行为进行预测，
    @Before
    public void init(){
        BDDMockito.given(userDao.createUser("admin")).willReturn(1);
        BDDMockito.given(userDao.createUser("")).willReturn(0);
        BDDMockito.given(userDao.createUser(null)).willThrow(NullPointerException.class);
    }

    @Test(expected=NullPointerException.class)
    public void testCreateUser() {
        Assert.assertEquals(Integer.valueOf(1),userDao.createUser("admin")) ;
        Assert.assertEquals(Integer.valueOf(0),userDao.createUser("")) ;
        Assert.assertEquals(Integer.valueOf(1),userDao.createUser(null)) ;
    }
}

对controller进行测试

第一种方式:
定义一个Controller，用作测试：

@RestController
public class UserController {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @GetMapping("/user/home")
    public String home(){
        logger.info("user home");
        return "user home";
    }

    @GetMapping("/user/show")
    public String show(@RequestParam("id") String id){
        logger.info("book show");
        return "show"+id;
    }
}

使用浏览器访问

http://localhost:8080/user/home
http://localhost:8080/user/show?id=100

使用测试类测试

@RunWith(SpringRunner.class)
//指定web环境，随机端口
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserControllerTest {

    //这个对象是运行在web环境的时候加载到spring容器中
    @Autowired
    private TestRestTemplate testRestTemplate;

    @Test
    public void testHome(){
        String context = testRestTemplate.getForObject("/user/home",String.class);
        Assert.assertEquals("user home",context);
    }

    @Test
    public void testShow(){
        String context = testRestTemplate.getForObject("/user/show?id=100",String.class);
        Assert.assertEquals("show10",context);
    }
}

第二种方式，使用@WebMvcTest注解

@RunWith(SpringRunner.class)
@WebMvcTest(controllers = UserController.class)
public class UserControllerTest2 {

    @Autowired
    public MockMvc mockMvc;

    @Test
    public void testHome() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk());
        mockMvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("user home"));
    }

    @Test
    public void testShow() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk());
        mockMvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("show400"));
    }
}

WebMvcTest

@WebMvcTest 不需要运行在web环境下，但是，需要指定controllers，表示需要测试哪些controllers。
这种方式只测试controller，controller里面的一些依赖，需要你自己去mock
@WebMvcTest 不会加载整个spring容器。

第三种方式
使用@SpringBootTest()与@AutoConfigureMockMvc结合，@SpringBootTest使用@SpringBootTest加载测试的spring上下文环境，@AutoConfigureMockMvc自动配置MockMvc这个类，

/**
 * @SpringBootTest 不能和  @WebMvcTest 同时使用
 * 如果使用MockMvc对象的话，需要另外加上@AutoConfigureMockMvc注解
 */
@RunWith(SpringRunner.class)
@SpringBootTest()
@AutoConfigureMockMvc
public class UserControllerTest3 {

    @Autowired
    private MockMvc mvc;

    @Test
    public void testHome() throws Exception {
        mvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk());
        mvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("user home"));
    }

    @Test
    public void testShow() throws Exception {
        mvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk());
        mvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("show400"));
    }
}

一个注解可以使测试类可以自动配置MockMvc这个类。