Test dell'unità Android Studio: leggere il file di dati (input)

In uno unit test, come posso leggere i dati da un file json sul mio file system (desktop), senza codificare il percorso?

Vorrei leggere l'input di prova (per i miei metodi di analisi) da un file invece di creare stringhe statiche.

Il file si trova nella stessa posizione del mio codice di unit test, ma posso anche posizionarlo da qualche altra parte nel progetto, se necessario. Sto usando Android Studio.

A seconda della android-gradle-pluginversione:

1. versione 1.5 e successive:

Basta inserire il file json src/test/resources/test.jsone referenziarlo come

classLoader.getResource("test.json"). 

Non è necessaria alcuna modifica graduale.

2. versione precedente alla 1.5 : (o se per qualche motivo la soluzione sopra non funziona)

1. Assicurati di utilizzare almeno Android Gradle Plugin versione 1.1 . Segui il link per configurare correttamente Android Studio.

2. Crea testdirectory. Metti le classi di unit test nella javadirectory e metti il ​​tuo file di risorse nella resdirectory. Android Studio dovrebbe contrassegnarli come segue:

   

3. Crea gradleattività per copiare le risorse nella directory delle classi per renderle visibili per classloader:

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

4. Ora puoi utilizzare questo metodo per ottenere il Fileriferimento per la risorsa file:

   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. Esegui un test unitario con Ctrl+ Shift+ F10su tutta la classe o su un metodo di test specifico.

Per i test di unità locali (rispetto ai test di strumentazione), puoi inserire file src/test/resourcese leggerli utilizzando classLoader. Ad esempio, il codice seguente apre il myFile.txtfile nella directory delle risorse.

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

Ha funzionato con

• Android Studio 1.5.1
• plugin gradle 1.3.1

Nel mio caso, la soluzione era aggiungere al file gradle

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

Dopo di che tutto è stato trovato da AS 2.3.1

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

Ho avuto molti problemi con le risorse di test in Android Studio, quindi ho impostato alcuni test per maggiore chiarezza. Nel mio progetto mobile(Applicazione Android) ho aggiunto i seguenti file:

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

La classe di test (tutti i test vengono superati):

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"));

Nello stesso progetto radice ho un progetto Java (non Android) chiamato data. Se aggiungo gli stessi file al progetto dati:

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

Quindi tutti i test precedenti falliranno se li eseguo da Android Studio, ma passano sulla riga di comando con ./gradlew data:test. Per aggirare il problema uso questo hack (in 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"))
}

Utilizzo: resource('/test.txt')

Android Studio 2.3, Gradle 3.3

Se vai su Esegui -> Modifica configurazioni -> JUnit e quindi selezioni la configurazione di esecuzione per i tuoi test unitari, c'è un'impostazione "Directory di lavoro". Questo dovrebbe indicare dovunque sia il tuo file json. Tieni presente che questo potrebbe rompere altri test.

Ho pensato di aggiungere qui le mie scoperte. So che questo è un po 'vecchio ma per le versioni più recenti di Gradle, dove NON c'è la directory src / test / resources, ma solo una singola directory delle risorse per l'intero progetto, devi aggiungere questa riga al tuo file Gradle.

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

In questo modo puoi accedere alla tua risorsa con:

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

Ho cercato questo e non sono riuscito a trovare una risposta, quindi ho deciso di aiutare gli altri qui.

In realtà, questo è ciò che ha funzionato per me con i test di strumentazione (con Android Studio versione 3.5.3 , Android Gradle Plugin versione 3.5.3 , Gradle versione 6.0.1 ):

1. Metti i tuoi file nella src/androidTest/assetscartella
2. Nel tuo file di prova:

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