web-dev-qa-db-fra.com

Comment créer des tests dans Android Studio?

Vient de télécharger Android Studio, qui est basé sur l’idée d’Intellij.

Comment créer des tests?

Je remarque qu’il existe une option pour créer un module de test mais que cela ne semble rien faire, créez seulement un nouveau projet avec src

J'ai aussi essayé d'appuyer sur la touche de raccourci CTRL + ALT + T, qui permet de créer des tests unitaires sur une classe existante, mais elle semble vouloir la placer dans le projet en cours. Bien sûr, cela n'aide pas avec TDD

Quelqu'un at-il une expérience ici?

androidunit-testingintellij-ideaandroid-studio
108
Martin

Cette réponse s'adresse aux personnes qui commencent tout juste à tester Android. Je vais vous donner deux exemples simples pour vous aider à comprendre comment fonctionnent les tests. Si vous suivez pendant les 10 prochaines minutes, vous serez tous prêts à ajouter vos tests à votre propre application. Je pense que vous serez surpris à quel point c'est facile. J'étais certainement.

Introduction à Android Test

Vous ferez deux types de tests différents.

  • Tests unitaires locaux. Ils sont exécutés localement sur la JVM (Java Virtual Machine). Comme ils sont locaux, ils sont rapides. Vous pouvez les utiliser pour tester les parties de votre code qui ont simplement besoin de Java et non des API Android. (Parfois, vous pouvez créer un faux objet API pour tester plus de choses localement. Cela s'appelle un moqueur . Un mock Context est un exemple.)
  • Tests instrumentés. Ces tests sont exécutés sur un périphérique réel ou dans l'émulateur. Cela les rend plus lents que les tests locaux. Cependant, ils sont plus flexibles, car vous disposez de l’API complète Android.

Créez un nouveau projet et vous verrez les dossiers par défaut suivants.

enter image description here

Tout est déjà là et n'attend que vous pour créer vos tests. Tout est déjà installé!

Comment créer des tests unitaires locaux

Ouvrez le fichier ExampleUnitTest présenté dans l'image ci-dessus. Ça devrait ressembler a quelque chose comme ca:

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        assertEquals(4, 2 + 2);
    }
}

Appuyez sur la double flèche verte pour exécuter tous les tests ou sur la flèche unique pour en exécuter un seul. (Dans ce cas, il n'y a qu'un seul test, ils font donc tous les deux la même chose.)

enter image description here

Il devrait passer (tant que 2 + 2 est toujours 4 lorsque vous lisez cette réponse). Félicitations, vous venez de faire votre premier test!

Faire votre propre test

Écrivons notre propre test. Ajoutez d’abord cette classe à votre projet d’application principal afin que nous ayons quelque chose à tester:

public class MyClass {
    public int add(int a, int b) {
        return a + b;
    }
}

Modifiez maintenant la méthode addition_isCorrect() dans la classe de test pour qu'elle ressemble au code suivant (ou ajoutez simplement une autre méthode portant un nom différent):

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        MyClass myClass = new MyClass();
        int result = myClass.add(2, 2);
        int expected = 4;
        assertEquals(expected, result);
    }
}

Exécutez-le à nouveau et vous devriez le voir passer. Félicitations, vous venez de créer votre propre premier test! (Bien, je suppose que techniquement, c'était le mien, mais, hé, assez proche. Ce qui est à moi est à vous.)

Comment créer des tests instrumentés

Ouvrez le fichier ExampleInstrumentedTest. Ça devrait ressembler a quelque chose comme ca:

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
    @Test
    public void useAppContext() throws Exception {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        assertEquals("com.example.myapp", appContext.getPackageName());
    }
}

Appuyez à nouveau sur l'un de ces boutons verts.

enter image description here

Tant que vous avez un périphérique réel connecté ou que l'émulateur est configuré, il devrait l'avoir démarré et exécuté votre application. Félicitations, vous venez de lancer votre premier test instrumenté!

Faire votre propre test

Les tests instrumentés utilisent Espresso pour exécuter les tests. C'est un peu comme votre propre petit utilisateur de robot que vous pouvez faire tester votre application. Vous pouvez lui dire de faire quelque chose comme appuyer sur un bouton ou lire les propriétés d'un TextView.

Vous pouvez écrire les instructions pour savoir comment faire le test à la main, mais comme nous venons de commencer, utilisons la fonction fonction d’enregistrement automatique . C'est super simple.

Commencez par ajouter un bouton à votre interface utilisateur afin que nous puissions travailler avec quelque chose. J'ai fait ça:

<?xml version="1.0" encoding="utf-8"?>
<Android.support.constraint.ConstraintLayout
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    xmlns:tools="http://schemas.Android.com/tools"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    tools:context="com.example.myapp.MainActivity">

    <Button
        Android:id="@+id/myButton"
        Android:text="Click me"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"/>

</Android.support.constraint.ConstraintLayout>

Puis appuyez sur Exécuter> Enregistrer le test d'espresso dans le menu.

enter image description here

Une fois l’opération lancée, cliquez sur le bouton dans l’émulateur, puis, pour terminer, choisissez OK dans la boîte de dialogue Enregistrer. Il devrait générer automatiquement le code de test suivant.

@LargeTest
@RunWith(AndroidJUnit4.class)
public class MainActivityTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);

    @Test
    public void mainActivityTest() {
        ViewInteraction appCompatButton = onView(
                allOf(withId(R.id.myButton), withText("Click me"), isDisplayed()));
        appCompatButton.perform(click());
    }
}

Génial! Vous venez de créer votre premier test instrumenté! C'était super facile. Vous devriez probablement ajouter une assertion pour en faire un vrai test, mais c'est assez facile à faire avec l'enregistreur aussi. Regardez cette vidéo pour aller un peu plus loin.

Une étude plus approfondie

Je regardais d'abord les vidéos, puis lisais la documentation. Tout cela est très utile. Le dernier lien est une série d’articles qui traitent de points importants à prendre en compte lors du choix d’un test.

49
Suragch

Edit: À partir de .1.8, cela est maintenant supporté par l'EDI . Veuillez suivre les instructions qui y figurent au lieu de suivre les instructions ci-dessous.

À la suite du Guide de l'utilisateur du plug-in Android Gradle , j'ai réussi à obtenir des tests sur la ligne de commande en effectuant les étapes suivantes sur un projet nouvellement créé (j'ai utilisé le package par défaut 'com.example.myapplication'):

  1. Ajouter un répertoire src/instrumentTest/Java pour les tests
  2. Ajouter une classe de test (extension ActivityTestCase) dans le package com.example.myapplication.test
  3. Démarrer un périphérique virtuel
  4. Sur la ligne de commande (dans le répertoire MyApplicationProject/MyApplication), utilisez la commande '../gradlew connectedInstrumentTest'.

Cela a exécuté mes tests et placé les résultats de test dans MyApplicationProject/MyApplication/build/reports/instrumentTests/connected. Je commence à tester Android applications, mais cela semble fonctionner correctement.

À partir de l'EDI, il est possible d'essayer et d'exécuter la même classe de test. Vous aurez besoin de

  1. Mettez à jour build.gradle pour répertorier Maven Central en tant que dépôt
  2. Mettez à jour build.gradle et ajoutez JUnit 3.8 en tant que dépendance instrumentTestCompile, par exemple. instrumentTestCompile 'junit: junit: 3.8'
  3. Dans 'Project Structure', déplacez manuellement JUnit pour qu'il soit le premier dans l'ordre de dépendance.

Cependant, cela échoue (le chemin de classe utilisé lors de l'exécution des tests ne contient pas le répertoire de sortie du test). Cependant, je ne suis pas sûr que cela fonctionnerait malgré tout, car je crois comprendre qu'un exécuteur de test spécifique à Android est requis.

36
Chris

Je suggère d'utiliser le fichier gradle.build.

  1. Ajouter un src/androidTest/Java répertoire pour les tests (Comme Chris commence à expliquer)

  2. Ouvrez le fichier gradle.build et spécifiez-y:

    Android {

    compileSdkVersion rootProject.compileSdkVersion
    buildToolsVersion rootProject.buildToolsVersion

    sourceSets {

        androidTest {
            Java.srcDirs = ['androidTest/Java']
        }
    }
}

  3. Appuyez sur "Synchroniser le projet avec le fichier Gradle" (dans le panneau supérieur). Vous devriez voir maintenant un dossier "Java" (à l'intérieur de "androidTest") est une couleur verte.

  4. Vous pouvez maintenant créer des fichiers de test et les exécuter.

20
Yuriy Chernyshov

Je pense que ce post de Rex St John est très utile pour les tests unitaires avec Android studio.

http://rexstjohn.com/wp-content/uploads/2014/01/Screen-Shot-2014-01-24-at-6.26.20-PM-300x137.png

12
Saeed Zarinfam

Android Studio v.2.3.3

Mettez en surbrillance le contexte de code que vous voulez tester et utilisez le raccourci clavier: CTRL + SHIFT + T

Utilisez l'interface de dialogue pour terminer votre configuration.

La structure de test est supposée refléter la disposition de votre package de projet pour de meilleurs résultats, mais vous pouvez créer manuellement des tests personnalisés, à condition que vous disposiez du répertoire et des paramètres de construction appropriés.

10
Hypersoft Systems

Dès maintenant (studio 0.61), maintenir une structure de projet appropriée est suffisant. Pas besoin de créer un projet de test séparé comme dans Eclipse (voir ci-dessous).

Tests structure

7
Daber

Android Studio continue d'évoluer, de sorte que les réponses ci-dessus ne seront éventuellement plus applicables. Pour la version actuelle de Android Studio 1.2.1.1, un tutoriel de Nice sur les tests est disponible à l'adresse suivante:

http://evgenii.com/blog/testing-activity-in-Android-studio-tutorial-part-1/

4
AndroidDev

L’un des principaux changements semble être que, avec Android Studio, l’application de test est intégrée au projet d’application.

Je ne sais pas si cela vous aidera, mais j'ai trouvé un guide pour effectuer des tests avec un projet Gradle. Guide de l'utilisateur Android Gradle

3
Kage

Le moyen le plus simple que j'ai trouvé est la rationalisation de mon article de blog suivant :

  1. Créez un dossier dans lequel vous écrirez tous vos tests unitaires (de préférence com.example.app.tests)
  2. Créez une nouvelle classe de test (de préférence NameOfClassTestedTests, i.e BankAccountLoginActivityTests)
  3. Étendre InstrumentationTestCase
  4. Ecrivez un test unitaire défaillant pour vous assurer que nous avons réussi à configurer les tests unitaires
  5. Notez qu'un nom de méthode de test unitaire doit commencer par le mot "test" (de préférence testTestedMethodNameExpectedResult () i.e testBankAccountValidationFailedShouldLogout ())
  6. Configurez votre projet pour les tests unitaires:
  7. Ouvrez le menu "Exécuter ..." et cliquez sur "Modifier les configurations".
  8. Cliquez sur le bouton +
  9. Sélectionnez le modèle Android Tests
  10. Entrez un nom pour votre configuration d'exécution (de préférence 'AppName Tests')
  11. Sélectionnez votre application dans la liste déroulante du module.
  12. Sélectionnez le bouton radio "Tout dans le package" (en général, vous voudriez sélectionner cette option car elle exécute tous les tests unitaires dans toutes vos classes de tests).
  13. Entrez le nom du package de test à l'étape 1 (par exemple, com.example.app.tests).
  14. Sélectionnez le périphérique sur lequel vous souhaitez exécuter vos tests
  15. Appliquer et sauvegarder la configuration
  16. Exécutez des tests unitaires (et prévoyez une défaillance):
  17. Sélectionnez votre configuration de tests nouvellement créée dans le menu Exécuter.
  18. Cliquez sur Exécuter et lisez les résultats dans la console de sortie.

Bonne chance pour rendre votre code plus lisible, maintenable et bien testé!

3
nurxyz

Android Studio est en quelque sorte une cible mouvante. Il s’agit tout d’abord d’un aperçu pour les développeurs, puis d’une version bêta. Le chemin d'accès aux classes de test du projet a changé au fil du temps, mais quelle que soit la version de AS utilisée, le chemin d'accès est déclaré dans votre fichier .iml. Actuellement, avec la version 0.8.3, vous trouverez ce qui suit dans le fichier iml interne:

      <sourceFolder url="file://$MODULE_DIR$/src/androidTest/res" type="Java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/resources" type="Java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/assets" type="Java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/aidl" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/Java" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/groovy" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/jni" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/rs" isTestSource="true" />

Le fichier .iml vous indique où placer vos classes de test.

2
Miguel El Merendero

À partir de Android Studio 1.1, nous disposons du support officiel (expérimental) pour la rédaction de tests unitaires (qui fonctionnent également en Roboélectrique).

Source: https://sites.google.com/a/Android.com/tools/tech-docs/unit-testing-support

2
marius bardan

Ajouter ci-dessous lib à l'intérieur du fichier gradle

 androidTestCompile('com.Android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.Android.support', module: 'support-annotations'
    })

Créez la classe HomeActivityTest dans le répertoire androidTest et avant d'exécuter le test, ajoutez la chaîne flurry_api_key et sender_id dans le fichier de ressources de chaîne, puis modifiez la valeur en cas d'échec et de réussite.

@RunWith(AndroidJUnit4.class)
public class HomeActivityTest
{
    private static final String SENDER_ID = "abc";
    private static final String RELEASE_FLURRY_API_KEY = "xyz";

    @Test
    public void gcmRegistrationId_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(SENDER_ID, appContext.getString(R.string.sender_id));
    }

    @Test
    public void flurryApiKey_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(RELEASE_FLURRY_API_KEY, appContext.getString(R.string.flurry_api_key));
    }
}
0
Bishwajeet Biswas