如何用MockK库在Kotlin中Mock Handler类解决单元测试空指针问题

问题场景 #

你的MyApplication代码如下：

public class MyApplication extends Application {
    private Handler handler;
    private Context context;

    @Override
    public void onCreate() {
        super.onCreate();
        context = getApplicationContext();

        handler = new Handler(context.getMainLooper()) {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 1:
                        // Handle message case 1
                        break;
                    case 2:
                        // Handle message case 2
                        break;
                    // Add more cases as needed
                    default:
                        // Handle other cases or provide a default behavior
                        break;
                }
            }
        };

        // Sending message with code 1 to the handler
        handler.obtainMessage(1).sendToTarget();

        // Sending message with code 2 to the handler
        handler.obtainMessage(2).sendToTarget();
    }
}

执行单元测试时，handler对象始终为空，尝试用以下MockK代码未达到预期：

every { mockContext.mainLooper } returns mockLooper
mockkConstructor(Handler::class)

问题原因 #

直接调用mockkConstructor(Handler::class)未指定构造函数的参数匹配逻辑，无法正确拦截new Handler(context.getMainLooper())的实例化过程；同时未正确模拟Application的getApplicationContext()返回值，导致上下文依赖缺失。另外，Handler是匿名内部类，单元测试中Looper不会自动循环处理消息，需要手动触发消息逻辑。

解决方案 #

以下是完整的MockK测试实现，确保Handler实例化并能验证消息处理逻辑：

import io.mockk.every
import io.mockk.mockk
import io.mockk.mockkConstructor
import io.mockk.verify
import io.mockk.spyk
import android.app.Application
import android.content.Context
import android.os.Handler
import android.os.Looper
import android.os.Message
import org.junit.Test

class MyApplicationTest {

    @Test
    fun testOnCreateHandlerInitializationAndMessageSending() {
        // 1. 初始化Mock对象
        val mockContext = mockk<Context>(relaxed = true)
        val mockLooper = mockk<Looper>(relaxed = true)
        val mockHandler = mockk<Handler>(relaxed = true)

        // 2. 模拟上下文的MainLooper返回mockLooper
        every { mockContext.mainLooper } returns mockLooper

        // 3. 拦截Handler构造函数，当传入mockLooper时返回mockHandler
        mockkConstructor(Handler::class)
        every { anyConstructed<Handler>(mockLooper) } returns mockHandler

        // 4. 包装MyApplication，模拟getApplicationContext()返回mockContext
        val myApp = spyk(MyApplication(), recordPrivateCalls = true)
        every { myApp.getApplicationContext() } returns mockContext

        // 5. 调用onCreate方法
        myApp.onCreate()

        // 6. 验证Handler实例化和消息发送
        verify { constructorMock<Handler>(mockLooper) } // 验证构造函数被调用
        verify { mockHandler.obtainMessage(1) } // 验证消息1被发送
        verify { mockHandler.obtainMessage(2) } // 验证消息2被发送
    }

    @Test
    fun testHandleMessageLogic() {
        // 1. 初始化Mock对象
        val mockContext = mockk<Context>(relaxed = true)
        val mockLooper = mockk<Looper>(relaxed = true)

        // 2. 模拟上下文和Looper
        every { mockContext.mainLooper } returns mockLooper

        // 3. 实例化Application并模拟上下文返回
        val myApp = spyk(MyApplication(), recordPrivateCalls = true)
        every { myApp.getApplicationContext() } returns mockContext

        // 4. 调用onCreate初始化handler
        myApp.onCreate()

        // 5. 通过反射获取private的handler实例
        val handlerField = MyApplication::class.java.getDeclaredField("handler")
        handlerField.isAccessible = true
        val handlerInstance = handlerField.get(myApp) as Handler

        // 6. 手动发送消息测试handleMessage逻辑
        val msg1 = Message.obtain().apply { what = 1 }
        handlerInstance.handleMessage(msg1)

        // 这里添加对应case1的逻辑验证，比如如果case1中有调用其他方法，需要提前mock并验证
        // 示例：verify { someMockedMethod() }

        val msg2 = Message.obtain().apply { what = 2 }
        handlerInstance.handleMessage(msg2)
        // 同理验证case2的逻辑
    }
}

关键说明 #

• 构造函数匹配：使用every { anyConstructed<Handler>(mockLooper) }明确匹配Handler构造时传入的Looper参数，确保mock实例被正确注入。
• 上下文模拟：用spyk包装MyApplication，覆盖getApplicationContext()返回mock上下文，解决依赖缺失问题。
• 消息逻辑测试：单元测试中Looper不会自动处理消息队列，需通过反射获取Handler实例后，手动调用handleMessage来验证分支逻辑。

内容的提问来源于stack exchange，提问作者Magic Man