Back to Repositories

Testing File Operations and Cache Strategies in Glide

This test suite examines Glide’s file handling capabilities, specifically focusing on the asFile() functionality and various disk cache strategies. It validates URL-based file operations and different caching behaviors in an Android environment.

Test Coverage Overview

The test suite provides comprehensive coverage of Glide’s file handling operations, focusing on URL-based resource loading and disk cache strategies.

Key areas tested include:

Basic URL to File conversion
Automatic disk cache strategy
Data-specific caching
Resource caching validation
Error handling for unsupported cache strategies

Implementation Analysis

The testing approach utilizes JUnit4 with AndroidJUnit4 runner for Android-specific testing context. It employs a combination of mock data loading and concurrent execution patterns to validate file operations.

Framework features utilized include:

ConcurrencyHelper for async operations
MockModelLoader for URL simulation
Custom test rules for model generation and cleanup

Technical Details

Testing tools and configuration:

JUnit4 test framework
AndroidX Test Core for application context
Custom TearDownGlide rule for cleanup
ModelGeneratorRule for test data generation
ByteArrayInputStream for mock data handling
Google Truth assertion library

Best Practices Demonstrated

The test suite exemplifies several testing best practices in Android development.

Notable practices include:

Proper test setup and teardown management
Isolation of test cases
Comprehensive error case handling
Mock data usage
Concurrent operation handling
Clear test method naming conventions

bumptech/glide

instrumentation/src/androidTest/java/com/bumptech/glide/AsFileTest.java

            
package com.bumptech.glide;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;

import android.content.Context;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.test.GlideApp;
import com.bumptech.glide.test.ModelGeneratorRule;
import com.bumptech.glide.test.ResourceIds;
import com.bumptech.glide.testutil.ConcurrencyHelper;
import com.bumptech.glide.testutil.MockModelLoader;
import com.bumptech.glide.testutil.TearDownGlide;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(AndroidJUnit4.class)
public class AsFileTest {
  private static final String URL = "https://imgs.xkcd.com/comics/mc_hammer_age.png";

  @Rule public final ModelGeneratorRule modelGeneratorRule = new ModelGeneratorRule();
  @Rule public final TearDownGlide tearDownGlide = new TearDownGlide();

  private final ConcurrencyHelper concurrency = new ConcurrencyHelper();
  private final Context context = ApplicationProvider.getApplicationContext();

  @Before
  public void setUp() {
    MockModelLoader.mock(URL, getData());
  }

  @Test
  public void asFile_withUrl_succeeds() {
    File file = concurrency.get(GlideApp.with(context).asFile().load(URL).submit());
    assertThat(file).isNotNull();
  }

  @Test
  public void asFile_withUrlAndDiskCacheStrategyAutomatic_succeeds() {
    File file =
        concurrency.get(
            GlideApp.with(context)
                .asFile()
                .diskCacheStrategy(DiskCacheStrategy.AUTOMATIC)
                .load(URL)
                .submit());
    assertThat(file).isNotNull();
  }

  @Test
  public void asFile_withUrlAndDiskCacheStrategyData_succeeds() {
    File file =
        concurrency.get(
            GlideApp.with(context)
                .asFile()
                .diskCacheStrategy(DiskCacheStrategy.DATA)
                .load(URL)
                .submit());
    assertThat(file).isNotNull();
  }

  @Test
  public void asFile_withUrlAndDiskCacheStrategyResource_fails() {
    try {
      concurrency.get(
          GlideApp.with(context)
              .asFile()
              .diskCacheStrategy(DiskCacheStrategy.RESOURCE)
              .load(URL)
              .submit());
      fail();
    } catch (RuntimeException e) {
      // expected.
    }
  }

  @Test
  public void asFile_withUrlAndDiskCacheStrategyAll_fails() {
    try {
      concurrency.get(
          GlideApp.with(context)
              .asFile()
              .diskCacheStrategy(DiskCacheStrategy.ALL)
              .load(URL)
              .submit());
      fail();
    } catch (RuntimeException e) {
      // Expected.
    }
  }

  private InputStream getData() {
    try {
      return new ByteArrayInputStream(modelGeneratorRule.asByteArray(ResourceIds.raw.canonical));
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
}