Android Kotlin中Volley网络请求全流程单元测试实现咨询

Absolutely, you can implement full-stack network testing with a stubbed backend using only local unit tests (no androidTest required)! Let's walk through fixing your NoClassDefFoundError and setting up the end-to-end test properly.

First: Fix the org/apache/http/StatusLine NoClassDefFoundError #

The error happens because local unit tests run on your computer's JVM, not an Android device/emulator—so the Android system's Apache HTTP classes aren't available by default, even if you're using OkHttpStack. Here are two quick fixes:

Option 1: Add Apache HTTP dependencies for testing #

Add these lines to your app-level build.gradle (under testImplementation):

testImplementation "org.apache.httpcomponents:httpcore:4.4.16"
testImplementation "org.apache.httpcomponents:httpclient:4.5.14"

This pulls in the missing Apache HTTP classes for your JVM test environment.

Option 2: Upgrade Volley & use OkHttp3-compatible stack #

If you're using an older Volley version, upgrade to the latest release (e.g., 1.2.1), and consider using Volley's official OkHttp3Stack instead of a custom OkHttpStack—it’s more JVM-test-friendly.

Second: Mock Context to work with Volley's RequestQueue #

Your mocked Context is missing critical methods Volley needs (like accessing the cache directory). Use Mockito to stub these required methods:

import org.mockito.Mock
import org.mockito.Mockito.`when`
import org.mockito.MockitoAnnotations
import java.io.File

class YourVolleyTest {
    @Mock
    private lateinit var mockContext: Context

    @Before
    fun setup() {
        MockitoAnnotations.openMocks(this)
        
        // Create a temporary cache directory for Volley
        val tempCacheDir = File(System.getProperty("java.io.tmpdir"), "volley-test-cache")
        tempCacheDir.mkdirs()
        
        // Stub Context methods Volley relies on
        `when`(mockContext.cacheDir).thenReturn(tempCacheDir)
        `when`(mockContext.applicationContext).thenReturn(mockContext)
    }
}

This gives Volley a valid place to store its cache, which is required for initializing the RequestQueue.

Third: Set up a stubbed backend with MockWebServer #

To test the full network stack (real HTTP requests, not mocked Volley components), use MockWebServer (a library that spins up a local temporary server to return predefined responses).

Step 1: Add MockWebServer dependency #

Add this to your build.gradle:

testImplementation "com.squareup.okhttp3:mockwebserver:4.11.0"

Step 2: Write the full unit test #

Here’s a complete example of testing a Volley request against the stubbed server:

import com.android.volley.Request
import com.android.volley.Response
import com.android.volley.VolleyError
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import org.junit.After
import org.junit.Before
import org.junit.Test
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit
import kotlin.test.assertEquals
import kotlin.test.fail

class YourVolleyTest {
    @Mock
    private lateinit var mockContext: Context
    private lateinit var mockWebServer: MockWebServer

    @Before
    fun setup() {
        MockitoAnnotations.openMocks(this)
        // Initialize mock context as shown earlier
        val tempCacheDir = File(System.getProperty("java.io.tmpdir"), "volley-test-cache")
        tempCacheDir.mkdirs()
        `when`(mockContext.cacheDir).thenReturn(tempCacheDir)
        `when`(mockContext.applicationContext).thenReturn(mockContext)
        
        // Start the mock server
        mockWebServer = MockWebServer()
        mockWebServer.start()
    }

    @After
    fun teardown() {
        // Shutdown the mock server after tests
        mockWebServer.shutdown()
    }

    @Test
    fun testVolleyRequestAgainstStubbedBackend() {
        // 1. Define your stubbed response
        val successResponse = MockResponse()
            .setResponseCode(200)
            .setBody("{\"status\": \"ok\", \"data\": \"test-value\"}")
        mockWebServer.enqueue(successResponse)

        // 2. Get the mock server's URL to use in your request
        val apiEndpoint = mockWebServer.url("/api/your-test-endpoint").toString()

        // 3. Create Volley RequestQueue with your OkHttp stack
        val okHttpClient = okhttp3.OkHttpClient()
        val requestQueue = Volley.newRequestQueue(mockContext, OkHttpStack(okHttpClient))

        // 4. Use CountDownLatch to wait for Volley's async request to finish
        val latch = CountDownLatch(1)
        var responseResult: String? = null
        var errorResult: VolleyError? = null

        // 5. Create and enqueue your Volley request
        val request = object : StringRequest(
            Request.Method.GET,
            apiEndpoint,
            Response.Listener { response ->
                responseResult = response
                latch.countDown()
            },
            Response.ErrorListener { error ->
                errorResult = error
                latch.countDown()
            }
        ) {}

        requestQueue.add(request)

        // Wait for the request to complete (timeout after 5 seconds)
        latch.await(5, TimeUnit.SECONDS)

        // 6. Verify the results
        errorResult?.let { fail("Request failed with error: ${it.message}") }
        assertEquals("{\"status\": \"ok\", \"data\": \"test-value\"}", responseResult)
    }
}

Key Notes #

• Async handling: Volley requests are asynchronous, so we use CountDownLatch to pause the test until the request completes.
• Full network stack: MockWebServer lets you test real HTTP requests (including headers, status codes, and response bodies) without hitting a real backend.
• Mockito setup: If you’re using Kotlin, add mockito-kotlin (testImplementation "org.mockito.kotlin:mockito-kotlin:4.1.0") for cleaner mock syntax.

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