Acabo de descargar Android Studio, que se basa en Intellij Idea.

¿Cómo se crearían pruebas?

Noto que hay una opción para crear un módulo de prueba, pero esto no parece hacer nada, solo crea un nuevo proyecto con src

También intenté presionar la tecla de acceso rápido CTRL + AlT + T que permite crear pruebas unitarias en una clase existente, pero parece querer colocarla en el proyecto actual. Por supuesto, esto no ayuda con TDD

¿Alguien tiene alguna experiencia aquí?

Esta respuesta es para personas que recién están comenzando con las pruebas de Android. Proporcionaré dos ejemplos simples para ayudarlo a ver cómo funcionan las pruebas. Si lo sigue durante los próximos 10 minutos, estará listo para comenzar a agregar sus pruebas a su propia aplicación. Creo que te sorprenderá lo fácil que es. Ciertamente lo estaba.

Introducción a las pruebas de Android

Hay dos tipos diferentes de pruebas que realizará.

• Pruebas unitarias locales. Estos se ejecutan localmente en la JVM (máquina virtual Java). Como son locales, son rápidos. Puede usarlos para probar las partes de su código que solo necesitan Java y no las API de Android. (A veces puedes crear un objeto API falso para probar más cosas localmente. Esto se llama burla . Una burla Contextes un ejemplo).
• Pruebas instrumentadas. Estas pruebas se ejecutan en un dispositivo real o en el emulador. Eso los hace más lentos que las pruebas locales. Sin embargo, son más flexibles porque tiene disponible la API de Android completa.

Cree un nuevo proyecto y verá las siguientes carpetas predeterminadas.

Todo ya está ahí y esperando a que cree sus pruebas. ¡Ya está todo configurado!

Cómo crear pruebas unitarias locales

Abra el ExampleUnitTestarchivo que se muestra en la imagen de arriba. debería verse algo como esto:

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

Presione la flecha verde doble para ejecutar todas las pruebas o la flecha verde única para ejecutar solo una. (En este caso, solo hay una prueba, por lo que ambos hacen lo mismo).

Debería aprobarse (siempre que 2 + 2esté quieto 4cuando esté leyendo esta respuesta). ¡Felicitaciones, acaba de ejecutar su primera prueba!

Haciendo tu propia prueba

Escribamos nuestra propia prueba. Primero agregue esta clase a su proyecto de aplicación principal para que tengamos algo que probar:

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

Ahora cambie el addition_isCorrect()método en la clase de prueba para que sea como el siguiente código (o simplemente agregue otro método con un nombre diferente):

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

Ejecútelo de nuevo y debería verlo pasar. ¡Felicitaciones, acaba de crear su propia primera prueba! (Bueno, supongo que técnicamente era mío, pero, oye, lo suficientemente cerca. Lo que es mío es tuyo).

Cómo crear pruebas instrumentadas

Abra el ExampleInstrumentedTestarchivo. debería verse algo como esto:

@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());
    }
}

Presiona uno de esos botones verdes nuevamente.

Siempre que tenga un dispositivo real conectado o el emulador configurado, debería haberlo iniciado y ejecutar su aplicación. ¡Felicitaciones, acaba de ejecutar su primera prueba instrumentada!

Haciendo tu propia prueba

Las pruebas instrumentadas utilizan Espresso para ejecutar las pruebas. Es como su propio pequeño usuario de robot que puede probar su aplicación. Puede decirle que haga algo como presionar un botón o leer las propiedades de un TextView.

Puede escribir las instrucciones sobre cómo hacer la prueba a mano, pero como estamos comenzando, usemos la función de grabación automática . Es super simple.

Primero agregue un botón a su interfaz de usuario para que tengamos algo con lo que trabajar. Hice esto:

<?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> 

Luego presione Ejecutar> Grabar prueba de espresso en el menú.

Después de que comience, haga clic en el botón en el emulador y luego, para terminar, elija Aceptar en el cuadro de diálogo Grabar. Debería generar automáticamente el siguiente código de prueba.

@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());
    }
}

¡Excelente! ¡Acaba de crear su primera prueba instrumentada! Eso fue muy fácil. Probablemente debería agregar una afirmación para que sea una prueba real, pero eso también es bastante fácil de hacer con la grabadora. Mira este video para profundizar un poco más.

Estudio adicional

Primero veía los videos y luego leía la documentación. Todo es muy útil. El último enlace es a una serie de artículos que cubren algunas cosas importantes en las que pensar al elegir qué probar.

• Patrones de prueba de Android (serie breve de videos de desarrolladores de Android)
• Introducción a las pruebas (documentos de Android)
• Tres pasos para codificar la calidad a través de TDD

Editar: A partir de 0.1.8, esto ahora es compatible con el IDE . Siga las instrucciones allí, en lugar de usar las instrucciones a continuación.

Siguiendo la Guía del usuario del complemento de Gradle para Android, pude hacer que las pruebas funcionaran en la línea de comando realizando los siguientes pasos en un proyecto recién creado (usé el paquete predeterminado 'com.example.myapplication'):

1. Agregue un directorio src / instrumentTest / java para las pruebas
2. Agregue una clase de prueba (extendiendo ActivityTestCase) en el paquete com.example.myapplication.test
3. Iniciar un dispositivo virtual
4. En la línea de comando (en el directorio MyApplicationProject / MyApplication) use el comando '../gradlew connectedInstrumentTest'

Esto ejecutó mis pruebas y colocó los resultados de la prueba en MyApplicationProject / MyApplication / build / reports / instrumentTests / connected. Soy nuevo en probar aplicaciones de Android, pero parece que funciona bien.

Desde dentro del IDE, es posible probar y ejecutar la misma clase de prueba. Necesitarás

1. Actualice build.gradle para listar Maven Central como un repositorio
2. Actualice build.gradle agregue JUnit 3.8 como una dependencia de instrumentTestCompile, por ejemplo, instrumentTestCompile 'junit: junit: 3.8'
3. En 'Estructura del proyecto', mueva JUnit manualmente para que sea el primero en el orden de dependencia

Sin embargo, esto falla (la ruta de clase utilizada cuando se ejecutan las pruebas falta el directorio de salida de la prueba). Sin embargo, no estoy seguro de que esto funcione independientemente, ya que tengo entendido que se requiere un ejecutor de pruebas específico de Android.

Sugeriría usar el archivo gradle.build .

1. Agregue un directorio src / androidTest / java para las pruebas (como Chris comienza a explicar)

2. Abra el archivo gradle.build y especifique allí:

   android {
   
       compileSdkVersion rootProject.compileSdkVersion
       buildToolsVersion rootProject.buildToolsVersion
   
       sourceSets {
   
           androidTest {
               java.srcDirs = ['androidTest/java']
           }
       }
   }

3. Presiona "Sincronizar proyecto con archivo Gradle" (en el panel superior). Ahora debería ver una carpeta "java" (dentro de "androidTest") es de color verde.

4. Ahora puede crear allí cualquier archivo de prueba y ejecutarlo.

Creo que esta publicación de Rex St John es muy útil para las pruebas unitarias con Android Studio.

_{(fuente: rexstjohn.com )}

Android Studio v.2.3.3

Resalte el contexto del código que desea probar y use la tecla de acceso rápido: CTRL+ SHIFT+T

Utilice la interfaz de diálogo para completar su configuración.

Se supone que el marco de prueba refleja el diseño del paquete de su proyecto para obtener mejores resultados, pero puede crear pruebas personalizadas manualmente, siempre que tenga el directorio y la configuración de compilación correctos.

A partir de ahora (estudio 0.61) es suficiente mantener la estructura adecuada del proyecto. No es necesario crear un proyecto de prueba separado como en eclipse (ver más abajo).

Android Studio sigue evolucionando, por lo que las respuestas anteriores eventualmente dejarán de ser aplicables. Para la versión actual de Android Studio 1.2.1.1, hay un buen tutorial sobre pruebas en:

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

Uno de los principales cambios que parece es que con Android Studio la aplicación de prueba está integrada en el proyecto de la aplicación.

No estoy seguro de si esto ayuda a su problema específico, pero encontré una guía sobre cómo hacer pruebas con un proyecto de Gradle. Guía del usuario de Android Gradle

La forma más fácil que encontré es la simplificada en mi siguiente publicación de blog :

1. Cree una carpeta en la que escribirá todas sus pruebas unitarias (preferiblemente com.example.app.tests)
2. Cree una nueva clase de prueba (preferiblemente NameOfClassTestedTests, es decir, BankAccountLoginActivityTests)
3. Extender InstrumentaciónTestCase
4. Escriba una prueba unitaria fallida para asegurarse de que logramos configurar correctamente las pruebas unitarias
5. Tenga en cuenta que el nombre de un método de prueba unitaria debe comenzar con la palabra "prueba" (preferiblemente testTestedMethodNameExpectedResult () es decir, testBankAccountValidationFailedShouldLogout ())
6. Configure su proyecto para pruebas unitarias:
7. Abra el menú 'Ejecutar ...' y haga clic en 'editar configuraciones'
8. Haga clic en el botón +
9. Seleccione la plantilla de pruebas de Android
10. Ingrese un nombre para su configuración de ejecución (preferiblemente 'AppName Tests')
11. Seleccione su aplicación en el cuadro combinado del módulo
12. Seleccione el botón de opción "Todo en paquete" (en general, querrá seleccionar esta opción porque ejecuta todas las pruebas unitarias en todas sus clases de prueba)
13. Complete el nombre del paquete de prueba del paso 1 (es decir, com.example.app.tests)
14. Seleccione el dispositivo en el que desea ejecutar sus pruebas
15. Aplicar y guardar la configuración
16. Ejecute pruebas unitarias (y espere fallas):
17. Seleccione su configuración de pruebas recién creada en el menú Ejecutar
18. Haga clic en Ejecutar y lea los resultados en la consola de salida.

¡Buena suerte haciendo que su código sea más legible, fácil de mantener y probado!

Android Studio ha sido una especie de objetivo en movimiento, primero fue una vista previa para desarrolladores y ahora está en versión beta. La ruta para las clases de prueba en el proyecto ha cambiado con el tiempo, pero no importa qué versión de AS esté utilizando, la ruta se declara en su archivo .iml. Actualmente, con la versión 0.8.3, encontrará lo siguiente dentro del archivo iml interno:

      <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" />

El archivo .iml le indica dónde colocar sus clases de prueba.

A partir de Android Studio 1.1, tenemos soporte oficial (experimental) para escribir pruebas unitarias (Roboelectric también funciona).

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

Agregue debajo de lib dentro del archivo gradle

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

Cree la clase HomeActivityTest dentro del directorio androidTest y, antes de ejecutar la prueba, agregue la cadena flurry_api_key y sender_id dentro del archivo de recursos de cadena y cambie el valor para el caso de error y éxito.

@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));
    }
}