Test unitaire Android Studio: lire le fichier de données (entrée)

Dans un test unitaire, comment puis-je lire des données à partir d'un fichier json sur mon système de fichiers (de bureau), sans coder en dur le chemin?

Je voudrais lire l'entrée de test (pour mes méthodes d'analyse) à partir d'un fichier au lieu de créer des chaînes statiques.

Le fichier se trouve au même emplacement que mon code de test unitaire, mais je peux également le placer ailleurs dans le projet si nécessaire. J'utilise Android Studio.

Selon la android-gradle-pluginversion:

1. version 1.5 et supérieure:

Mettez simplement le fichier json src/test/resources/test.jsonet référencez-le comme

classLoader.getResource("test.json"). 

Aucune modification de gradle n'est nécessaire.

2. version inférieure à 1.5 : (ou si pour une raison quelconque la solution ci-dessus ne fonctionne pas)

1. Assurez-vous que vous utilisez au moins Android Gradle Plugin version 1.1 . Suivez le lien pour configurer correctement Android Studio.

2. Créer un testrépertoire. Placez les classes de test unitaire dans le javarépertoire et placez votre fichier de ressources dans le resrépertoire. Android Studio doit les marquer comme suit:

   

3. Créez une gradletâche pour copier les ressources dans le répertoire des classes pour les rendre visibles pour classloader:

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

4. Vous pouvez maintenant utiliser cette méthode pour obtenir une Fileréférence pour la ressource de fichier:

   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. Exécutez le test unitaire par Ctrl+ Shift+ F10sur toute la classe ou sur une méthode de test spécifique.

Pour les tests unitaires locaux (par rapport aux tests d'instrumentation), vous pouvez placer des fichiers sous src/test/resourceset les lire à l'aide de classLoader. Par exemple, le code suivant ouvre le myFile.txtfichier dans le répertoire des ressources.

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

Cela a fonctionné avec

• Android Studio 1.5.1
• plugin gradle 1.3.1

Dans mon cas, la solution était d'ajouter au fichier gradle

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

Après cela, tout a été trouvé par AS 2.3.1

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

J'ai eu beaucoup de problèmes avec les ressources de test dans Android Studio, j'ai donc mis en place quelques tests pour plus de clarté. Dans mon projet mobile(Application Android), j'ai ajouté les fichiers suivants:

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

La classe de test (tous les tests réussissent):

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

Dans le même projet racine, j'ai un projet Java (pas Android) appelé data. Si j'ajoute les mêmes fichiers au projet de données:

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

Ensuite, tous les tests ci-dessus échoueront si je les exécute depuis Android Studio, mais ils passent sur la ligne de commande avec ./gradlew data:test. Pour contourner cela, j'utilise ce hack (dans 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"))
}

Usage: resource('/test.txt')

Android Studio 2.3, Gradle 3.3

Si vous allez dans Exécuter -> Modifier les configurations -> JUnit puis sélectionnez la configuration d'exécution pour vos tests unitaires, il existe un paramètre «Répertoire de travail». Cela devrait indiquer où se trouve votre fichier json. Gardez à l'esprit que cela pourrait casser d'autres tests.

Je pensais que je devrais ajouter mes conclusions ici. Je sais que c'est un peu vieux mais pour les nouvelles versions de Gradle, où il n'y a PAS de répertoire src / test / resources, mais un seul répertoire de ressources pour l'ensemble du projet, vous devez ajouter cette ligne à votre fichier Gradle.

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

En faisant cela, vous pouvez accéder à votre ressource avec:

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

J'ai cherché ceci et je n'ai pas trouvé de réponse, alors j'ai décidé d'aider les autres ici.

En fait, c'est ce qui a fonctionné pour moi avec les tests d'instrumentation (exécutant Android Studio version 3.5.3 , Android Gradle Plugin version 3.5.3 , Gradle version 6.0.1 ):

1. Mettez vos fichiers dans un src/androidTest/assetsdossier
2. Dans votre fichier de test:

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