540 lines
20 KiB
Markdown
540 lines
20 KiB
Markdown
# Spirng Test
|
||
## Unit Test
|
||
### Introduce
|
||
在运行单元测试时，无需实际启动容器，可以通过`mock objects`的方式来独立的对代码进行测试。故而，单元测试通常运行的十分快。
|
||
|
||
### Mock Objects
|
||
spring包含如下专门用于`mock`的包
|
||
- Environment
|
||
- JNDI
|
||
- Servlet API
|
||
- Spring Web Reactive
|
||
|
||
#### Environment
|
||
`org.springframework.mock.env`包中包含`Environment`和`PropertySource`抽象类的实现。在编写针对依赖环境变量代码的测试时，`MockEnvironment`和`MockPropertySource`将会非常有用。
|
||
|
||
#### JNDI
|
||
`org.springframework.mock.jndi`包中包含`JNDI SPI`的部分实现，因而，可以建立一个简单的JNDI环境。
|
||
|
||
#### Servlet API
|
||
`org.springframework.mock.web`包中包含一整套`servlet api mock object`，这些mock object针对spring web mvc框架使用。
|
||
|
||
### Unit Test Support Class
|
||
spring中包含一系列类来帮助单元测试：
|
||
- 通用测试组件
|
||
- spring mvc测试组件
|
||
|
||
#### 通用测试组件
|
||
`org.springframework.test.util`中包含一系列类用于单元测试和集成测试。
|
||
|
||
`AopTestUtils`中拥有一系列aop相关的方法。可以通过AopTestUtils中的方法获取隐藏在一层或多层代理下的`target`对象。
|
||
|
||
`ReflectionTestUtils`中拥有一系列反射相关的方法，可以通过ReflectionTestUtils中的方法修改常量值、访问非public的field或method。通常，ReflectionTestUtils可用于如下场景：
|
||
- ORM框架中针对protected或private filed的访问
|
||
- spring注解（@Autowired、@Inject，@Resource，@PostConstruct）中对于类中非公有成员的访问
|
||
|
||
`TestSocketUtils`可以查找本地可以连接的TCP端口，通常用于集成测试。
|
||
|
||
#### spring mvc测试组件
|
||
`org.springframework.test.web`包包含了`ModelAndViewAssert`.
|
||
|
||
## 集成测试
|
||
集成测试拥有如下特性：
|
||
- 通过spring上下文正确注入
|
||
- 可以通过JDBC或ORM工具进行数据库访问
|
||
|
||
集成测试会实际启动spring容器，故而速度要比单元测试慢。
|
||
|
||
### 集成测试主要目标
|
||
集成测试主要支持如下目标：
|
||
- 在测试之间管理ioc容器缓存
|
||
- 在测试时提供依赖注入
|
||
- 在集成测试时提供事务管理
|
||
- 在编写集成测试时提供spring相关的类
|
||
|
||
### Context Management and Caching
|
||
spring TestContext framework支持一致导入`ApplicationContext`和`WebApplicationContext`，并针对这些context做缓存。
|
||
|
||
> 支持对于已导入上下文的缓存是很重要的，因为spring实例化对象时花费的时间会很长。故而，如果针对每个测试的每个test fixture之前，都会加载对象的开销。
|
||
|
||
默认情况下，一旦`ApplicationContext`导入，那么每个test都会复用导入的上下文。故而，每个test suite都只会有一次导入开销，并且后续测试的执行要快得多。其中，`test suite`代表运行在相同jvm中的所有测试，
|
||
|
||
|
||
### Test Fixtures依赖注入
|
||
当TestContext framework导入应用上下文时，其可以针对test class使用依赖注入。并且，可以跨测试场景重复使用应用程序上下文，避免在独立的测试用例之间重复执行fixture设置。
|
||
|
||
### 事务管理
|
||
TextContext framework默认会为每个test都创建并回滚一个事务。在编写test代码时，可以假定已经存在事务。默认情况下，test方法执行完后事务会被回滚，数据库状态会恢复到执行前的状态。
|
||
|
||
如果想要令test方法执行后事务被提交，可以使用`@Commit`注解。
|
||
|
||
### JDBC Support
|
||
`org.springframework.test.jdbc`包中包含`JdbcTestUtils`，其中包含了一系列jdbc相关的工具方法。
|
||
|
||
## Spring TestContext Framework
|
||
Spring TestContext Framework提供了通用的、注解驱动的单元测试和集成测试支持，并且该支持和底层的测试框架无关。并且，TestContext Framework的约定大于配置，并可以通过注解来覆盖默认值。
|
||
|
||
### Context Management
|
||
每个`TestContext`都为其负责的测试类提供了上下文管理和caching支持。测试类实例并不直接访问配置好的`ApplicationContext`，但如果test class实现了`ApplciationContextAware`接口，那么测试类中将包含field指向ApplicationContext的引用。
|
||
|
||
在使用TestContext Framework时，test class并不需要继承特定类或实现特定接口来配置test class所属的application context，相应的，application context的配置是通过在类级别指定`@ContextConfiguration`来实现的。如果test class没有显式的声明application context resource location或component classes，那么配置好的`ContextLoader`将会决定如何从默认location或默认configuration classes中加载context。
|
||
|
||
#### Context Configuration with Xml Resource
|
||
如果要通过xml配置的方式来导入`ApplicationContext`，可以指定`@ContextConfiguration`中的`location`属性，其是执行xml文件路径的数组。以`/`开头的路径代表classpath，而相对路径则是代表相对class文件的路径。示例如下：
|
||
```java
|
||
@ExtendWith(SpringExtension.class)
|
||
// ApplicationContext will be loaded from "/app-config.xml" and
|
||
// "/test-config.xml" in the root of the classpath
|
||
@ContextConfiguration(locations = {"/app-config.xml", "/test-config.xml"})
|
||
class MyTest {
|
||
// class body...
|
||
}
|
||
```
|
||
如果@ContextConfiguration省略了`location`和`value`属性，那么其默认会探测test class所在的路径。例如`com.example.MyTest`类，其默认会探测`classpath:com/example/MyTest-context.xml`。
|
||
|
||
#### Context Configuration with Component Classes
|
||
为test加载ApplicationContext时，可以通过componet classes来实现。为此，可以为test class指定`@ConfigurationContext`注解，并且在注解的`classes`属性指定一个class数组，其实现如下：
|
||
```java
|
||
@ExtendWith(SpringExtension.class)
|
||
// ApplicationContext will be loaded from AppConfig and TestConfig
|
||
@ContextConfiguration(classes = {AppConfig.class, TestConfig.class})
|
||
class MyTest {
|
||
// class body...
|
||
}
|
||
```
|
||
> 其中，component classes可以指定如下的任何一种对象：
|
||
> - 有`@Configuration`注解的类
|
||
> - 有`@Component`、`@Service`、`@Repository`等注解的类
|
||
> - 有`@Bean`注解方法返回的bean对象所属类
|
||
> - 其他任何被注册为spring bean对象的类
|
||
|
||
如果，在指定@ConfigurationContext注解时，省略了`classes`属性，那么TestContext Framework会尝试查找是否存在默认的classes。`AnnotationConfigContextLoader`和`AnnotationConfigWebContextLoader`会查找Test Class中所有的静态内部类，并判断其是否符合configuration class需求。
|
||
|
||
示例如下所示：
|
||
```java
|
||
@SpringJUnitConfig
|
||
// ApplicationContext will be loaded from the static nested Config class
|
||
class OrderServiceTest {
|
||
|
||
@Configuration
|
||
static class Config {
|
||
|
||
// this bean will be injected into the OrderServiceTest class
|
||
@Bean
|
||
OrderService orderService() {
|
||
OrderService orderService = new OrderServiceImpl();
|
||
// set properties, etc.
|
||
return orderService;
|
||
}
|
||
}
|
||
|
||
@Autowired
|
||
OrderService orderService;
|
||
|
||
@Test
|
||
void testOrderService() {
|
||
// test the orderService
|
||
}
|
||
|
||
}
|
||
```
|
||
|
||
#### Context Configuration继承
|
||
`@ContextConfiguration`支持从父类继承componet classes、resource locations、context initializers。可以指定`inheritLocations`和`inheritInitializers`来决定是否继承父类componet classes、resource locations、context initializers，两属性默认值为`true`。
|
||
|
||
示例如下：
|
||
```java
|
||
@ExtendWith(SpringExtension.class)
|
||
// ApplicationContext will be loaded from "/base-config.xml"
|
||
// in the root of the classpath
|
||
@ContextConfiguration("/base-config.xml")
|
||
class BaseTest {
|
||
// class body...
|
||
}
|
||
|
||
// ApplicationContext will be loaded from "/base-config.xml" and
|
||
// "/extended-config.xml" in the root of the classpath
|
||
@ContextConfiguration("/extended-config.xml")
|
||
class ExtendedTest extends BaseTest {
|
||
// class body...
|
||
}
|
||
```
|
||
|
||
```java
|
||
// ApplicationContext will be loaded from BaseConfig
|
||
@SpringJUnitConfig(BaseConfig.class)
|
||
class BaseTest {
|
||
// class body...
|
||
}
|
||
|
||
// ApplicationContext will be loaded from BaseConfig and ExtendedConfig
|
||
@SpringJUnitConfig(ExtendedConfig.class)
|
||
class ExtendedTest extends BaseTest {
|
||
// class body...
|
||
}
|
||
```
|
||
|
||
```java
|
||
// ApplicationContext will be initialized by BaseInitializer
|
||
@SpringJUnitConfig(initializers = BaseInitializer.class)
|
||
class BaseTest {
|
||
// class body...
|
||
}
|
||
|
||
// ApplicationContext will be initialized by BaseInitializer
|
||
// and ExtendedInitializer
|
||
@SpringJUnitConfig(initializers = ExtendedInitializer.class)
|
||
class ExtendedTest extends BaseTest {
|
||
// class body...
|
||
}
|
||
```
|
||
#### Context Configuration with Environment Profiles
|
||
可以通过为test class指定`@ActiveProfiles`注解来指定激活的profiles。
|
||
|
||
```java
|
||
@ExtendWith(SpringExtension.class)
|
||
// ApplicationContext will be loaded from "classpath:/app-config.xml"
|
||
@ContextConfiguration("/app-config.xml")
|
||
@ActiveProfiles("dev")
|
||
class TransferServiceTest {
|
||
|
||
@Autowired
|
||
TransferService transferService;
|
||
|
||
@Test
|
||
void testTransferService() {
|
||
// test the transferService
|
||
}
|
||
}
|
||
```
|
||
`@ActiveProfiles`同样支持`inheritProfiles`属性，默认为true，可以关闭：
|
||
```java
|
||
// "dev" profile overridden with "production"
|
||
@ActiveProfiles(profiles = "production", inheritProfiles = false)
|
||
class ProductionTransferServiceTest extends AbstractIntegrationTest {
|
||
// test body
|
||
}
|
||
```
|
||
|
||
#### Context Configuration with TestPropertySource
|
||
可以通过在test class上声明`@TestPropertySource`注解来指定test properties文件位置。
|
||
|
||
`@TestPropertySource`可以指定lcoations和value属性，默认情况下支持xml和properties类型的文件，也可以通过`factory`指定一个`PropertySourceFactory`来支持不同格式的文件，例如`yaml`等。
|
||
|
||
每个path都会被解释为spring resource。
|
||
|
||
示例如下所示：
|
||
```java
|
||
@ContextConfiguration
|
||
@TestPropertySource("/test.properties")
|
||
class MyIntegrationTests {
|
||
// class body...
|
||
}
|
||
```
|
||
```java
|
||
@ContextConfiguration
|
||
@TestPropertySource(properties = {"timezone = GMT", "port = 4242"})
|
||
class MyIntegrationTests {
|
||
// class body...
|
||
}
|
||
```
|
||
如果在声明`@TestPropertySource`时没有指定locations和value属性的值，其会在test class所在路径去查找。例如`com.example.MyTest`其默认会去查找`classpath:com/example/MyTest.properties`.
|
||
|
||
##### 优先级
|
||
test properties的优先级将会比定义在操作系统environment、java system properties、应用程序手动添加的propertySource高。
|
||
|
||
##### 继承和覆盖
|
||
`@TestPropertySource`注解也支持`inheritLocations`和`inheritProperties`属性，可以从父类中继承resource location和inline properties。默认情况下，两属性的值为true。
|
||
|
||
示例如下：
|
||
```java
|
||
@TestPropertySource("base.properties")
|
||
@ContextConfiguration
|
||
class BaseTest {
|
||
// ...
|
||
}
|
||
|
||
@TestPropertySource("extended.properties")
|
||
@ContextConfiguration
|
||
class ExtendedTest extends BaseTest {
|
||
// ...
|
||
}
|
||
```
|
||
```java
|
||
@TestPropertySource(properties = "key1 = value1")
|
||
@ContextConfiguration
|
||
class BaseTest {
|
||
// ...
|
||
}
|
||
|
||
@TestPropertySource(properties = "key2 = value2")
|
||
@ContextConfiguration
|
||
class ExtendedTest extends BaseTest {
|
||
// ...
|
||
}
|
||
```
|
||
#### Loading WebApplicationContext
|
||
如果要导入WebApplicationContext，可以使用`@WebAppConfiguration`.
|
||
|
||
在使用`@WebAppConfiguration`注解之后，还可以自由使用`@ConfigurationContext`等类。
|
||
|
||
```java
|
||
@ExtendWith(SpringExtension.class)
|
||
|
||
// defaults to "file:src/main/webapp"
|
||
@WebAppConfiguration
|
||
|
||
// detects "WacTests-context.xml" in the same package
|
||
// or static nested @Configuration classes
|
||
@ContextConfiguration
|
||
class WacTests {
|
||
//...
|
||
}
|
||
```
|
||
|
||
#### Context Caching
|
||
一旦TestContext framework为test导入了Application Context，那么context将会被缓存，并且为之后相同test suite中所有有相同context configuration的test复用。
|
||
|
||
一个`ApplicationContext`可以被其创建时的参数组唯一标识，创建ApplicationContext所用到的参数将会产生一个唯一的key，该key将会作为context缓存的key。context cache key将会用到如下参数：
|
||
- `locations`(`@ContextConfiguration`)
|
||
- `classes`(`@ContextConfiguration`)
|
||
- `contextInitializerClasses`(`@ContextConfiguration`)
|
||
- `contextCustomizers`(`ContextCustomizerFactory`)
|
||
- `contextLoader`(`@ContextConfiguration`)
|
||
- `parent`(`@ContextHierarchy`)
|
||
- `activeProfiles`(`@ActiveProfiles`)
|
||
- `propertySourceDescriptors`(`@TestPropertySource`)
|
||
- `propertySourceProperties`(`@TestPropertySource`)
|
||
- `resourceBasePath`(来源于`@WebAppConfiguration`)
|
||
|
||
|
||
如果两个test classes对应的key相同，那么它们将共用application context。
|
||
|
||
该context cache默认大小上限为32，到到达上限后，将采用`LRU`来淘汰被缓存的context。
|
||
|
||
### Test Fixture Dependency Injection
|
||
test class中的依赖对象将会自动从application context中注入，可以使用setter注入、field注入。
|
||
|
||
示例如下所示：
|
||
```java
|
||
@ExtendWith(SpringExtension.class)
|
||
// specifies the Spring configuration to load for this test fixture
|
||
@ContextConfiguration("repository-config.xml")
|
||
class HibernateTitleRepositoryTests {
|
||
|
||
// this instance will be dependency injected by type
|
||
@Autowired
|
||
HibernateTitleRepository titleRepository;
|
||
|
||
@Test
|
||
void findById() {
|
||
Title title = titleRepository.findById(new Long(10));
|
||
assertNotNull(title);
|
||
}
|
||
}
|
||
```
|
||
setter注入示例如下所示：
|
||
```java
|
||
@ExtendWith(SpringExtension.class)
|
||
// specifies the Spring configuration to load for this test fixture
|
||
@ContextConfiguration("repository-config.xml")
|
||
class HibernateTitleRepositoryTests {
|
||
|
||
// this instance will be dependency injected by type
|
||
HibernateTitleRepository titleRepository;
|
||
|
||
@Autowired
|
||
void setTitleRepository(HibernateTitleRepository titleRepository) {
|
||
this.titleRepository = titleRepository;
|
||
}
|
||
|
||
@Test
|
||
void findById() {
|
||
Title title = titleRepository.findById(new Long(10));
|
||
assertNotNull(title);
|
||
}
|
||
}
|
||
```
|
||
### 事务管理
|
||
为了启用事务支持，需要在`ApplicationContext`中配置`PlatformTransactionManager`bean，此外，必须在test方法上声明`@Transactional`注解。
|
||
|
||
test-managed transaction是由`TransactionalTestExecutionListener`管理的，spring-managed transaction和applicaion-managed transaction都会加入到test-managed transaction，但是当指定了spring-managed transaction和applicaion-managed transaction的传播行为时，可能会在独立事务中运行。
|
||
|
||
> 当为test method指定@Transactional注解时，会导致test方法在事务中运行，并且默认会在事务完成后自动回滚。若test method没有指定@Transactional注解，那么test method将不会在事务中运行。test lifecycle method并不支持添加@Transactional注解。
|
||
|
||
示例如下所示：
|
||
```java
|
||
@SpringJUnitConfig(TestConfig.class)
|
||
@Transactional
|
||
class HibernateUserRepositoryTests {
|
||
|
||
@Autowired
|
||
HibernateUserRepository repository;
|
||
|
||
@Autowired
|
||
SessionFactory sessionFactory;
|
||
|
||
JdbcTemplate jdbcTemplate;
|
||
|
||
@Autowired
|
||
void setDataSource(DataSource dataSource) {
|
||
this.jdbcTemplate = new JdbcTemplate(dataSource);
|
||
}
|
||
|
||
@Test
|
||
void createUser() {
|
||
// track initial state in test database:
|
||
final int count = countRowsInTable("user");
|
||
|
||
User user = new User(...);
|
||
repository.save(user);
|
||
|
||
// Manual flush is required to avoid false positive in test
|
||
sessionFactory.getCurrentSession().flush();
|
||
assertNumUsers(count + 1);
|
||
}
|
||
|
||
private int countRowsInTable(String tableName) {
|
||
return JdbcTestUtils.countRowsInTable(this.jdbcTemplate, tableName);
|
||
}
|
||
|
||
private void assertNumUsers(int expected) {
|
||
assertEquals("Number of rows in the [user] table.", expected, countRowsInTable("user"));
|
||
}
|
||
}
|
||
```
|
||
|
||
#### 事务提交和回滚行为
|
||
默认情况下，事务在test方法执行完后自动会回滚，但是，事务执行完后的行为可以通过`@Commit`或`@Rollback`注解来控制。
|
||
|
||
|
||
如下是所有事务相关注解演示：
|
||
```java
|
||
@SpringJUnitConfig
|
||
@Transactional(transactionManager = "txMgr")
|
||
@Commit
|
||
class FictitiousTransactionalTest {
|
||
|
||
@BeforeTransaction
|
||
void verifyInitialDatabaseState() {
|
||
// logic to verify the initial state before a transaction is started
|
||
}
|
||
|
||
@BeforeEach
|
||
void setUpTestDataWithinTransaction() {
|
||
// set up test data within the transaction
|
||
}
|
||
|
||
@Test
|
||
// overrides the class-level @Commit setting
|
||
@Rollback
|
||
void modifyDatabaseWithinTransaction() {
|
||
// logic which uses the test data and modifies database state
|
||
}
|
||
|
||
@AfterEach
|
||
void tearDownWithinTransaction() {
|
||
// run "tear down" logic within the transaction
|
||
}
|
||
|
||
@AfterTransaction
|
||
void verifyFinalDatabaseState() {
|
||
// logic to verify the final state after transaction has rolled back
|
||
}
|
||
|
||
}
|
||
```
|
||
### test request
|
||
spring mvc中的测试示例如下所示：
|
||
```java
|
||
@SpringJUnitWebConfig
|
||
class RequestScopedBeanTests {
|
||
|
||
@Autowired UserService userService;
|
||
@Autowired MockHttpServletRequest request;
|
||
|
||
@Test
|
||
void requestScope() {
|
||
request.setParameter("user", "enigma");
|
||
request.setParameter("pswd", "$pr!ng");
|
||
|
||
LoginResults results = userService.loginUser();
|
||
// assert results
|
||
}
|
||
}
|
||
```
|
||
|
||
## spring boot test
|
||
spring boot提供了`@SpringBootTest`注解，可以作为`@ContextConfiguration`注解的代替。该类实际是通过spring boot项目的启动类来创建了一个ApplicationContext。
|
||
|
||
默认情况下，`@SpringBootTest`并不会启动server，可以使用注解的`webEnvironment`来对运行环境重新定义，该属性可选值如下：
|
||
- `MOCK`(默认)：将会导入一个ApplicationContext并且提供一个mock web environment。内置的server将不会被启动。如果classpath中没有web环境，那么其将会只创建一个非web的ApplicationContext。其可以和基于mock的`@AutoConfigureMockMvc`与`@AutoConfigureWebTestClient`一起使用
|
||
- `RANDOM_PORT`：导入`WebServerApplicationContext`并提供一个真实的web环境，内部server启动，并监听随机端口
|
||
- `DEFINED_PORT`导入`WebServerApplicationContext`并提供一个真实的web环境，内部server启动，监听指定端口（默认8080）
|
||
- `NONE`：通过SpringApplication导入ApplicationContext，但是不提供任何web环境
|
||
|
||
### @TestConfiguration
|
||
如果想要为测试新建Configuration顶级类，不应该使用`@Configuration`注解，这样会被@SpringBootApplciation或@ComponentScan扫描到，应该使用`@TestConfiguration`注解，并将类修改为嵌套类。
|
||
|
||
如果@TestConfiguration为顶层类，那么该类不会被注册，应该显式import：
|
||
```java
|
||
@RunWith(SpringRunner.class)
|
||
@SpringBootTest
|
||
@Import(MyTestsConfiguration.class)
|
||
public class MyTests {
|
||
|
||
@Test
|
||
public void exampleTest() {
|
||
...
|
||
}
|
||
|
||
}
|
||
```
|
||
|
||
### testing with mock environment
|
||
```java
|
||
import org.junit.Test;
|
||
import org.junit.runner.RunWith;
|
||
|
||
import org.springframework.beans.factory.annotation.Autowired;
|
||
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
|
||
import org.springframework.boot.test.context.SpringBootTest;
|
||
import org.springframework.test.context.junit4.SpringRunner;
|
||
import org.springframework.test.web.servlet.MockMvc;
|
||
|
||
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
|
||
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
|
||
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
|
||
|
||
@RunWith(SpringRunner.class)
|
||
@SpringBootTest
|
||
@AutoConfigureMockMvc
|
||
public class MockMvcExampleTests {
|
||
|
||
@Autowired
|
||
private MockMvc mvc;
|
||
|
||
@Test
|
||
public void exampleTest() throws Exception {
|
||
this.mvc.perform(get("/")).andExpect(status().isOk())
|
||
.andExpect(content().string("Hello World"));
|
||
}
|
||
|
||
}
|
||
```
|
||
|
||
### slice
|
||
通常，测试时只需要部分configuration，例如只需要service层而不需要web层。
|
||
|
||
`spring-boot-test-autoconfigure`模块提供了一系列注解，可以进行slice操作。该模块提供了`@…Test`格式的注解用于导入ApplicationContext，并提供了一个或多个`@AutoConfigure…`来自定义自动装配设置。
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|