Je viens de télécharger Android Studio basé sur Intellij Idea.

Comment créerait-on des tests?

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

J'ai également essayé d'appuyer sur la touche de raccourci CTRL + AlT + T qui permet de créer des tests unitaires sur une classe existante mais il 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?

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

Introduction aux tests Android

Il existe deux types de tests différents que vous ferez.

• Tests unitaires locaux. Ceux-ci 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 n'ont besoin que de Java et non des API Android. (Parfois, vous pouvez créer un faux objet API pour tester plus de choses localement. C'est ce qu'on appelle une moquerie . Une simulationContext est un exemple.)
• Tests instrumentés. Ces tests sont exécutés sur un appareil 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 Android complète.

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

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

Comment créer des tests unitaires locaux

Ouvrez le ExampleUnitTestfichier montré 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 verte unique pour n'en exécuter qu'un. (Dans ce cas, il n'y a qu'un seul test, donc ils font tous les deux la même chose.)

Cela devrait passer (tant qu'il 2 + 2est encore4 quand 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;
    }
}

Maintenant, changez la addition_isCorrect()méthode dans la classe de test pour qu'elle ressemble au code suivant (ou ajoutez simplement une autre méthode avec 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! (Eh bien, je suppose que techniquement c'était à moi, mais bon, assez proche. Ce qui est à moi est à vous.)

Comment créer des tests instrumentés

Ouvrez le ExampleInstrumentedTestfichier. Ç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.

Tant que vous avez un vrai appareil connecté ou que l'émulateur est configuré, il aurait dû le démarrer et exécuter votre application. Félicitations, vous venez de faire 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 faire le test à la main, mais puisque nous ne faisons que commencer, utilisons la fonction d'enregistrement automatique . C'est super simple.

Ajoutez d'abord un bouton à votre interface utilisateur pour que nous ayons quelque chose avec quoi travailler. 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> 

Appuyez ensuite sur Exécuter> Enregistrer le test expresso dans le menu.

Après avoir démarré, 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 également assez facile à faire avec l'enregistreur. Regardez cette vidéo pour aller un peu plus loin.

Une étude plus approfondie

Je regardais d'abord les vidéos, puis je lisais la documentation. Tout cela est très utile. Le dernier lien est vers une série d'articles qui couvrent des points importants à prendre en compte lors du choix des éléments à tester.

• Modèles de test Android (courte série de vidéos de développeurs Android)
• Premiers pas avec les tests (documentation Android)
• Trois étapes pour coder la qualité via TDD

Edit: Depuis la version 0.1.8, cela est désormais pris en charge dans l'EDI . Veuillez suivre les instructions ci-dessous, au lieu d'utiliser les instructions ci-dessous.

En suivant le guide de l'utilisateur du plug-in Android Gradle, j'ai pu faire fonctionner 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. Ajoutez une classe de test (étendant ActivityTestCase) dans le package com.example.myapplication.test
3. Démarrer un appareil 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 des tests dans MyApplicationProject / MyApplication / build / reports / instrumentTests / connected. Je suis nouveau dans le test des applications Android, mais cela semble fonctionner correctement.

Depuis l'EDI, il est possible d'essayer d'exécuter la même classe de test. Vous devrez

1. Mettez à jour build.gradle pour lister Maven Central en tant que dépôt
2. Mettre à jour build.gradle ajouter JUnit 3.8 comme une dépendance instrumentTestCompile, par exemple instrumentTestCompile 'junit: junit: 3.8'
3. Dans 'Structure du projet', déplacez manuellement JUnit pour être 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 testeur de test spécifique à Android est nécessaire.

Je suggérerais d'utiliser le fichier gradle.build .

1. Ajoutez un répertoire src / androidTest / java pour les tests (comme Chris commence à l'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 de couleur verte.

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

Je pense que cet article de Rex St John est très utile pour les tests unitaires avec Android Studio.

_{(source: rexstjohn.com )}

Android Studio v.2.3.3

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

Utilisez l'interface de dialogue pour terminer votre configuration.

Le cadre de test est censé 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.

Pour l'instant (studio 0.61), il suffit de maintenir une structure de projet appropriée. Pas besoin de créer un projet de test séparé comme dans eclipse (voir ci-dessous).

Android Studio ne cesse d'évoluer, de sorte que les réponses ci-dessus ne seront finalement plus applicables. Pour la version actuelle d'Android Studio 1.2.1.1, il existe un joli tutoriel sur les tests sur:

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

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

Je ne sais pas si cela aide votre problème spécifique, mais j'ai trouvé un guide sur la réalisation de tests avec un projet Gradle. Guide de l'utilisateur Android Gradle

Le moyen le plus simple que j'ai trouvé est le simplifié dans 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, c'est-à-dire BankAccountLoginActivityTests)
3. Étendre InstrumentationTestCase
4. Ecrire un test unitaire en échec pour vous assurer que nous avons réussi la configuration des tests unitaires
5. Notez qu'un nom de méthode de test unitaire doit commencer par le mot «test» (de préférence testTestedMethodNameExpectedResult () ie 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 de tests Android
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 la case d'option "Tout dans le package" (généralement vous souhaitez sélectionner cette option car elle exécute tous les tests unitaires dans toutes vos classes de test)
13. Remplissez le nom du package de test à partir de l'étape 1 (c'est-à-dire com.example.app.tests)
14. Sélectionnez l'appareil sur lequel vous souhaitez exécuter vos tests
15. Appliquer et enregistrer la configuration
16. Exécutez des tests unitaires (et attendez-vous à un échec):
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é!

Android Studio a été une sorte de cible mobile, étant d'abord un aperçu du développeur et maintenant en version bêta. Le chemin des classes de test dans le projet a changé avec le temps, mais quelle que soit la version d'AS que vous utilisez, le chemin 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.

Depuis Android Studio 1.1, nous avons un support officiel (expérimental) pour l'écriture de tests unitaires (Roboelectric fonctionne également).

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

Ajouter ci-dessous lib dans le 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 et 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));
    }
}