Teste de unidade do Android Studio: ler arquivo de dados (entrada)

Em um teste de unidade, como posso ler dados de um arquivo json em meu sistema de arquivos (desktop), sem codificar o caminho?

Gostaria de ler a entrada de teste (para meus métodos de análise) de um arquivo em vez de criar Strings estáticas.

O arquivo está no mesmo local que meu código de teste de unidade, mas também posso colocá-lo em outro lugar do projeto, se necessário. Estou usando o Android Studio.

Dependendo da android-gradle-pluginversão:

1. versão 1.5 e superior:

Basta colocar o arquivo json src/test/resources/test.jsone referenciá-lo como

classLoader.getResource("test.json"). 

Nenhuma modificação gradle é necessária.

2. versão abaixo de 1.5 : (ou se por algum motivo a solução acima não funcionar)

1. Certifique-se de usar pelo menos o Android Gradle Plugin versão 1.1 . Siga o link para configurar o Android Studio corretamente.

2. Crie o testdiretório. Coloque classes de teste de unidade no javadiretório e coloque seu arquivo de recursos no resdiretório. O Android Studio deve marcá-los como segue:

   

3. Crie uma gradletarefa para copiar recursos no diretório de classes para torná-los visíveis para classloader:

   android{
      ...
   }
   
   task copyResDirectoryToClasses(type: Copy){
       from "${projectDir}/src/test/res"
       into "${buildDir}/intermediates/classes/test/debug/res"
   }
   
   assembleDebug.dependsOn(copyResDirectoryToClasses)

4. Agora você pode usar este método para obter Filereferência para o recurso de arquivo:

   private static File getFileFromPath(Object obj, String fileName) {
       ClassLoader classLoader = obj.getClass().getClassLoader();
       URL resource = classLoader.getResource(fileName);
       return new File(resource.getPath());
   }
   
   @Test
   public void fileObjectShouldNotBeNull() throws Exception {
       File file = getFileFromPath(this, "res/test.json");
       assertThat(file, notNullValue());
   }

5. Execute o teste de unidade Ctrl+ Shift+ F10em toda a classe ou método de teste específico.

Para testes de unidade locais (vs. testes de instrumentação), você pode colocar arquivos src/test/resourcese lê-los usando classLoader. Por exemplo, o código a seguir abre o myFile.txtarquivo no diretório de recursos.

InputStream in = this.getClass().getClassLoader().getResourceAsStream("myFile.txt");

Funcionou com

• Android Studio 1.5.1
• plugin gradle 1.3.1

No meu caso, a solução foi adicionar ao arquivo gradle

sourceSets {
    test.resources.srcDirs += 'src/unitTests/resources'
  } 

Depois disso tudo foi encontrado pelo AS 2.3.1

javaClass.classLoader.getResourceAsStream("countries.txt")

Tive muitos problemas com recursos de teste no Android Studio, então configurei alguns testes para maior clareza. No meu projeto mobile(aplicativo Android), adicionei os seguintes arquivos:

mobile/src/test/java/test/ResourceTest.java
mobile/src/test/resources/test.txt
mobile/src/test/resources/test/samePackage.txt

A classe de teste (todos os testes são aprovados):

assertTrue(getClass().getResource("test.txt") == null);
assertTrue(getClass().getResource("/test.txt").getPath().endsWith("test.txt"));
assertTrue(getClass().getResource("samePackage.txt").getPath().endsWith("test/samePackage.txt"));
assertTrue(getClass().getResource("/test/samePackage.txt").getPath().endsWith("test/samePackage.txt"));
assertTrue(getClass().getClassLoader().getResource("test.txt").getPath().endsWith("test.txt"));
assertTrue(getClass().getClassLoader().getResource("test/samePackage.txt").getPath().endsWith("test/samePackage.txt"));

No mesmo projeto raiz, tenho um projeto Java (não Android) chamado data. Se eu adicionar os mesmos arquivos ao projeto de dados:

data/src/test/java/test/ResourceTest.java
data/src/test/resources/test.txt
data/src/test/resources/test/samePackage.txt

Então, todos os testes acima falharão se eu executá-los no Android Studio, mas eles passam na linha de comando com ./gradlew data:test. Para contornar isso, eu uso este hack (em Groovy)

def resource(String path) {
    getClass().getResource(path) ?:
            // Hack to load test resources when executing tests from Android Studio
            new File(getClass().getClassLoader().getResource('.').path
                    .replace('/build/classes/test/', "/build/resources/test$path"))
}

Uso: resource('/test.txt')

Android Studio 2.3, Gradle 3.3

Se você acessar Executar -> Editar configurações -> JUnit e selecionar a configuração de execução para seus testes de unidade, haverá uma configuração de 'Diretório de trabalho'. Isso deve apontar para onde quer que esteja seu arquivo json. Lembre-se de que isso pode quebrar outros testes.

Achei que deveria adicionar minhas descobertas aqui. Eu sei que isso é um pouco antigo, mas para as versões mais recentes do Gradle, onde NÃO existe o diretório src / test / resources, mas apenas um único diretório de recursos para todo o projeto, é necessário adicionar esta linha ao arquivo Gradle.

android {
   testOptions {
      unitTests {
         includeAndroidResources = true
      }
    }
}

Ao fazer isso, você pode acessar seu recurso com:

 this.getClass().getClassLoader().getResourceAsStream(fileName);

Tenho procurado por isso e não consegui encontrar uma resposta, então decidi ajudar outras pessoas aqui.

Na verdade, isso é o que funcionou para mim com os testes de instrumentação (executando o Android Studio versão 3.5.3 , Android Gradle Plugin versão 3.5.3 , Gradle versão 6.0.1 ):

1. Coloque seus arquivos na src/androidTest/assetspasta
2. Em seu arquivo de teste:

InputStream is = InstrumentationRegistry.getInstrumentation().getContext().getAssets().open("filename.txt");