一、什么是单元测试？
在 Java 中，单元测试就是为了测试某一个类里的某一个方法是否正常执行，而编写的测试代码。
当我们需要对某一个类里的某一个方法进行单元测试时，首先要确认好以下几个问题：
① 这个方法的功能是什么？
- 参数（如果有的话）
- 返回值（如果有的话）
- 具体操作
② 测试方法应该做什么？
- 构造参数（如果需要的话）
- 构造返回值（如果需要的话）
- 验证结果
③ 什么是实际的输出？
④ 什么是预期的输出？
二、单元测试需要用到哪些框架？
JUnit：
JUnit 是一个 Java 编程语言的单元测试框架，能够方便开发人员快速编写单元测试代码。 JUnit 使用注解来识别测试方法（JUnit4），并提供断言机制来验证预期结果。JUnit 只能运行在本地开发环境的 Java 虚拟机上。
Mockito：
Mockito 是一个用于 Java 单元测试中的 mocking 框架，mock 就是模拟的意思。在编写单元测试代码时，有时候我们不需要某个对象真实执行某个方法的代码，只是需要该对象在调用该方法时按照我们的预期返回特定值即可，这时就可以 mock 一个对象出来使用，非常方便。
Robolectric：
JUnit 和 Mockito 都是针对 Java 平台的测试框架。对于 Android 应用开发来说，我们需要调用 Android SDK 的 API，开发好的应用程序需要打包成 APK 文件并安装到 Android 设备上才能运行测试，效率很低。
Robolectric 框架实现了一套在 Java 虚拟机上能运行的 Android SDK，从而使得 Android 应用程序能够脱离 Android 环境运行测试，提高了测试效率。
三、如何搭建单元测试环境？
① 在 module 的 build.gradle 中添加以下内容，并执行 Gradle 同步
dependencies {
...
testImplementation 'junit:junit:4.13.2'
testImplementation 'org.mockito:mockito-core:3.3.3'
testImplementation "org.robolectric:robolectric:4.3.1"
testImplementation 'androidx.test:core:1.0.0'
...
}
② 在 test 目录下新建一个 Java 文件
public class UnitTestRobolectricTestRunner extends RobolectricTestRunner {
private static final int DEFAULT_SDK = 28;
static {
System.setProperty("robolectric.dependency.repo.id", "Samsung");
System.setProperty("robolectric.dependency.repo.url", "http://IP:PORT/lm/content/groups/public/");
}
public UnitTestRobolectricTestRunner(Class<?> testClass) throws InitializationError {
super(testClass);
}
@Override
protected Config buildGlobalConfig() {
return new Config.Builder()
.setApplication(android.app.Application.class)
.setSdk(DEFAULT_SDK)
.build();
}
}
③ 在 test 目录下再新建一个 Java 文件，并运行测试看是否执行成功
@RunWith(UnitTestRobolectricTestRunner.class)
public class MainActivityTest {
@Test
public void test_onCreate() {
MainActivity activity = Robolectric.buildActivity(MainActivity.class).create().get();
TextView textView = activity.findViewById(R.id.tv);
Assert.assertEquals("Hello World!", textView.getText().toString());
}
}
四、如何编写单元测试代码？
JUnit4 的基本使用
① 基础方法注解
@Test：被注解的方法是个测试方法。
@Before：被注解的方法会在每个测试方法执行前都调用一次。
@After：被注解的方法会在每个测试方法执行后都调用一次。
@BeforeClass：被注解的方法会在所有的测试方法执行前调用一次。
@AfterClass：被注解的方法会在所有的测试方法执行后调用一次。
@Ignore：被注解的方法会被忽略，不执行。
② 常用断言
JUnit 提供了一些辅助方法，用来帮助我们确定被测试方法是否按照预期正常执行，这些辅助方法称为断言。
assertEquals：验证两个值是否相等。
assertNotEquals：验证两个值是否不相等。
assertArrayEquals：验证两个数组是否相等。
assertSame：验证两个引用是否指向同一个对象。
assertNotSame：验证两个引用是否指向不同对象。
assertNull：验证某个对象是否为 null。
assertNotNull：验证某个对象是否不为 null。
assertTrue：验证某个条件是否为 true。
assertFalse：验证某个条件是否为 false。
③ Hamcrest 与 assertThat
JUnit 提供的断言验证的内容较为简单，如果需要验证较为复杂的内容可以使用 Hamcrest 表达式类库，它提供了一套匹配符。使用 Gradle 引入 JUnit4 时会同时引入 Hamcrest 相关类库，无需额外引入。
public static <T> void assertThat(T actual, Matcher<? super T> matcher)
==> 可以用来进行 字符串、数值、集合、对象、逻辑 等的匹配。
Mockito 的基本使用
① mock
创建一个模拟对象，Mockito 会记住它所 mock 对象的所有调用，为后续的验证做准备。
默认情况下，调用 mock 对象的方法是不会真实执行的，对于带返回值的方法会返回默认值，比如 null、0 或者 false 等。当然我们也可以让 mock 对象真实执行方法。
② when
当 mock 对象调用其方法时，开发人员可以根据测试需要指定相应的响应，比如返回特定的值、抛出异常或者真实执行方法等。
when(...).thenReturn(...)：当调用某个方法时返回特定值。
when(...).thenThrow(...)：当调用某个方法时抛出异常。
doReturn(...).when(...)：返回特定值当调用某个方法时。
doThrow(...).when(...)：抛出异常当调用某个方法时。
doNothing(...).when(...)：不做任何事情当调用某个方法时。
doCallRealMethod(...).when(...)：真实执行方法当调用某个方法时。
doAnswer(desiredAnswer).when(mockObject).targetMethod(args)
③ verify
负责验证 mock 对象是否调用了相应的方法。
Robolectric 的基本使用
① Activity 测试
@Deprecated
public static <T extends Activity> T setupActivity(Class<T> activityClass)
==> 创建一个 Activity，创建后的 Activity 会经历 onCreate、onStart、onResume 这几个生命周期。
public static <T extends Activity> ActivityController<T> buildActivity(Class<T> activityClass)
==> 创建一个ActivityController，然后需要自己手动控制 Activity 的生命周期。
② Button 测试
public boolean performClick()
==> 执行 Button 点击操作。
public boolean performLongClick()
==> 执行 Button 长按操作。
③ Shadow
Shadow 是影子的意思，Robolectric 定义了很多 Shadow 类，用来修改或者扩展 Android SDK 中类的行为。
当一个 Android SDK 中的类被实例化时，Robolectric 会去寻找对应的影子类，如果找到了则会创建一个影子对象并与实例对象相关联。当实例对象中的方法被调用时，Robolectric 会保证影子对象中相应的方法被调用。
@Implements(Activity.class)
public class ShadowActivity extends ShadowContextThemeWrapper
@RealObject
protected Activity realActivity;
自定义 Shadow：
public class NetworkUtil {
public static boolean isNetworkConnected(Context context) {
ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (cm == null) {
return false;
}
NetworkInfo networkInfo = cm.getActiveNetworkInfo();
return networkInfo != null && networkInfo.isConnected();
}
}
@Implements(NetworkUtil.class)
public class ShadowNetworkUtil {
private static boolean sNetworkConnected;
@Implementation
public static boolean isNetworkConnected(Context context) {
return sNetworkConnected;
}
public static void setNetworkConnected(boolean networkConnected) {
sNetworkConnected = networkConnected;
}
}
@RunWith(UnitTestRobolectricTestRunner.class)
public class RobolectricShadowTest {
private RobolectricShadow mRobolectricShadow;
private NetworkManager mNetworkManager;
@Before
public void setUp() {
mNetworkManager = mock(NetworkManager.class);
mRobolectricShadow = new RobolectricShadow(mNetworkManager);
}
@After
public void tearDown() {
mRobolectricShadow = null;
}
@Config(shadows = {ShadowNetworkUtil.class})
@Test
public void test_isNetworkRequestSuccess() {
String strUrl = null;
Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
verify(mNetworkManager, never()).doNetworkRequest(anyString());
strUrl = "testUrl";
Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
verify(mNetworkManager, never()).doNetworkRequest(anyString());
strUrl = "https://testUrl";
//将 Shadow 类的网络连接状态设置为 false
ShadowNetworkUtil.setNetworkConnected(false);
System.out.println("isNetworkConnected_1: " + NetworkUtil.isNetworkConnected(ApplicationProvider.getApplicationContext()));
Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
verify(mNetworkManager, never()).doNetworkRequest(anyString());
//将 Shadow 类的网络连接状态设置为 true
ShadowNetworkUtil.setNetworkConnected(true);
System.out.println("isNetworkConnected_2: " + NetworkUtil.isNetworkConnected(ApplicationProvider.getApplicationContext()));
doReturn("response").when(mNetworkManager).doNetworkRequest(anyString());
Assert.assertTrue(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
verify(mNetworkManager).doNetworkRequest(strUrl);
reset(mNetworkManager);
doReturn(null).when(mNetworkManager).doNetworkRequest(anyString());
Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
verify(mNetworkManager).doNetworkRequest(strUrl);
}
}
五、单元测试是如何跑起来的？
① 程序入口
java.lang.RuntimeException: Just a test
at com.tomorrow.unittestdemo.HowToRunTest.test(HowToRunTest.java:9)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498) ==> 反射调用，执行测试方法
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
at org.junit.runners.ParentRunner.run(ParentRunner.java:413) ==> Test Runner：BlockJUnit4ClassRunner
at org.junit.runner.JUnitCore.run(JUnitCore.java:137) ==> 导入的 JUnit 库程序入口
at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58) ==> 集成开发工具的 JUnit 插件相关代码
② Test Runner
Test Runner 是一个用于执行测试代码和输出测试结果的组件。
JUnit4 默认使用的是 BlockJUnit4ClassRunner。另外，也可以使用 @RunWith 指定 Test Runner，比如当程序中调用了 Android SDK 的代码或者需要使用 Shadow 机制时就要指定为 RobolectricTestRunner。
③ 运行时注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Test {
}
④ 反射调用
@Override
protected Object runReflectiveCall() throws Throwable {
return method.invoke(target, params);
}
六、ApprovalTests 库
对于 JavaBean 和 POJO 的单元测试，推荐使用 ApprovalTests 库。
① 添加依赖
testImplementation 'com.approvaltests:approvaltests:9.3.0'
② 重写 toString() 方法
一般我们重写类的 toString() 方法，是使用 Alt + Insert，然后选择 toString() 来重写，但是自带的模板生成的 toString() 不能通过 ApprovalTests 库的测试。
我们可以通过自定义 toString() 模板来解决，新建模板的方法： ALt + Insert -> toString() -> Settings -> Templates -> 新建模板，比如命名为 MyToStringTemlate，模板内容可参考如下：
@NonNull
public java.lang.String toString() {
final java.lang.StringBuilder sb = new java.lang.StringBuilder("$classname{");
#set ($i = 0)
#foreach ($member in $members)#if ($i == 0)
sb.append("#####
#else
sb.append(",####
#end#if ($member.string || $member.date)
\"$member.name\":\"")####
#else
\"$member.name\":")####
#end#if ($member.primitiveArray || $member.objectArray)
.append(java.util.Arrays.toString($member.name));
#elseif ($member.string || $member.date)
.append($member.accessor).append('\"');
#else
.append($member.accessor);
#end#set ($i = $i + 1)
#end
sb.append('}');
return sb.toString();
}
例子：
//JavaBean（可以使用 Alt + Insert，选择 Getter and Setter，自动生成 Getter 跟 Setter 方法）
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//使用默认 toString() 模板
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
==> Person{name='Android', age=10}
//使用自定义 toString() 模板
@Override
@NonNull
public String toString() {
final StringBuilder sb = new StringBuilder("Person{");
sb.append("\"name\":\"").append(name).append('\"');
sb.append(",\"age\":").append(age);
sb.append('}');
return sb.toString();
}
==> Person{"name":"Android","age":10}
//使用 Getter 方法替代直接使用属性名，目的是测试 Getter 方法
@Override
@NonNull
public String toString() {
final StringBuilder sb = new StringBuilder("Person{");
sb.append("\"name\":\"").append(getName()).append('\"');
sb.append(",\"age\":").append(getAge());
sb.append('}');
return sb.toString();
}
==> Person{"name":"Android","age":10}
③ 运行测试
public class PeopleTest {
@Test
public void testJavaBean() {
Person person = new Person();
person.setName("Android");
person.setAge(10);
Approvals.verify(person);
}
}
第一次运行会失败，ApprovalTests 库会生成一个文件：PeopleTest.testJavaBean.received.txt，需要将该文件的名字改为：PeopleTest.testJavaBean.approved.txt，再次运行即可成功。
网友评论