Coil单元测试实现方法及单元测试中Mock Coil网络层的可行性咨询

Hey there, these are solid questions when it comes to testing Coil—let’s walk through both in detail, since testing image loading logic is often overlooked but super important.

Coil provides dedicated testing utilities to make unit testing image loading straightforward. Here’s a step-by-step approach:

• Add Coil Test Dependencies
  First, include the Coil test artifact in your module-level build.gradle:

  testImplementation("io.coil-kt:coil-test:2.5.0")
  // For Android context in unit tests, add Robolectric:
  testImplementation("org.robolectric:robolectric:4.12.1")
  

• Use Coil’s Test Components
  Coil’s TestComponentFactory replaces real network/bitmap loading with test-friendly implementations, so you avoid hitting actual networks or dealing with real bitmaps in unit tests. Build a test-specific ImageLoader like this:

  val context = ApplicationProvider.getApplicationContext<Context>()
  val imageLoader = ImageLoader.Builder(context)
      .components { add(TestComponentFactory()) }
      .build()
  

• Write Test Cases
  You can test common scenarios like successful loads, failed requests, or cached responses. For example, testing a successful load with a test bitmap:

  @Test
  fun `load image successfully with test component`() = runTest {
      val request = ImageRequest.Builder(context)
          .data("https://example.com/image.jpg")
          .build()
  
      val result = imageLoader.execute(request)
      assert(result is SuccessResult)
      // Verify the bitmap uses Coil's test placeholder dimensions
      assert((result as SuccessResult).bitmap.width == 1)
  }
  

Absolutely! MockWebServer is a perfect tool to mock Coil’s network requests, letting you test how your code handles different responses (success, 404, slow loads, etc.). Here’s how to set it up:

• Add MockWebServer Dependency
  Include it in your module-level build.gradle:

  testImplementation("com.squareup.okhttp3:mockwebserver:4.12.0")
  

• Set Up MockWebServer in Tests
  Start the server before tests, enqueue mock responses, and point Coil to the server’s URL. Here’s a complete example:

  class CoilNetworkMockTest {
      private lateinit var mockWebServer: MockWebServer
  
      @Before
      fun setUp() {
          mockWebServer = MockWebServer()
          mockWebServer.start()
      }
  
      @After
      fun tearDown() {
          mockWebServer.shutdown()
      }
  
      @Test
      fun `load image from mock web server`() = runTest {
          // Enqueue a successful response with a test bitmap
          val testBitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
          val outputStream = ByteArrayOutputStream()
          testBitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
  
          val mockResponse = MockResponse()
              .setResponseCode(200)
              .setBody(outputStream.toByteArray())
  
          mockWebServer.enqueue(mockResponse)
  
          // Get the mock server's URL
          val mockUrl = mockWebServer.url("/test-image.jpg").toString()
  
          // Configure Coil to use the default OkHttpClient (which hits the mock server)
          val context = ApplicationProvider.getApplicationContext<Context>()
          val imageLoader = ImageLoader.Builder(context).build()
  
          // Execute the request
          val request = ImageRequest.Builder(context)
              .data(mockUrl)
              .build()
  
          val result = imageLoader.execute(request)
  
          // Verify success and bitmap dimensions
          assert(result is SuccessResult)
          assert((result as SuccessResult).bitmap.width == 100)
  
          // Verify the server received exactly one request
          val recordedRequest = mockWebServer.takeRequest()
          assert(recordedRequest.path == "/test-image.jpg")
      }
  
      @Test
      fun `handle 404 error from mock server`() = runTest {
          mockWebServer.enqueue(MockResponse().setResponseCode(404))
  
          val mockUrl = mockWebServer.url("/missing-image.jpg").toString()
          val imageLoader = ImageLoader.Builder(ApplicationProvider.getApplicationContext()).build()
          val request = ImageRequest.Builder(ApplicationProvider.getApplicationContext())
              .data(mockUrl)
              .build()
  
          val result = imageLoader.execute(request)
          assert(result is ErrorResult)
          assert((result as ErrorResult).throwable is HttpException)
      }
  }
  

• Alternative: Mock Coil’s ImageLoader Directly
  If you don’t need to test network interactions, you can mock the ImageLoader interface directly with a library like MockK:

  @Test
  fun `mock image loader directly`() = runTest {
      val mockImageLoader = mockk<ImageLoader>()
      coEvery { mockImageLoader.execute(any()) } returns SuccessResult(mockk())
  
      // Use the mockImageLoader in your code and verify interactions
      coVerify { mockImageLoader.execute(any()) }
  }
  

  This is great for verifying your code calls Coil correctly, without testing the network layer itself.

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