unit test studio run pruebas hacer como codigo automatizadas android unit-testing intellij-idea android-studio

test - ¿Cómo puedo crear pruebas en Android Studio?



test android hardware (12)

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

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

Acabo de descargar Android Studio que está basado en Intellij Idea.

¿Cómo crearía uno las pruebas?

Noté 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í?

A partir de ahora (estudio 0.61) mantener una estructura de proyecto adecuada es suficiente. No es necesario crear un proyecto de prueba por separado como en Eclipse (ver a continuación).

Añada a continuación 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 clase HomeActivityTest dentro del directorio androidTest y antes de ejecutar la prueba agregue flurry_api_key y sender_id cadena dentro del archivo de recursos de cadena y cambie el valor para el caso de falla 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)); } }

Android Studio ha sido una especie de objetivo en movimiento, primero una vista previa de desarrollador y ahora está en 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 te dice dónde colocar tus clases de prueba.

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

Siguiendo la Guía del usuario de Android Gradle Plugin, pude realizar pruebas trabajando en la línea de comandos realizando los siguientes pasos en un proyecto recién creado (utilicé el paquete predeterminado ''com.example.myapplication''):

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

Esto ejecutó mis pruebas y colocó los resultados de la prueba en MyApplicationProject / MyApplication / build / reports / instrumentTests / connected. Soy nuevo para probar aplicaciones de Android, pero parece funcionar 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. Actualizar build.gradle agregar JUnit 3.8 como una dependencia de InstrumentTestCompile, por ejemplo, instrumentTestCompile ''junit: junit: 3.8''
  3. En ''Estructura del proyecto'', mueva manualmente JUnit para ser el primero en la orden de dependencia

Sin embargo, esto falla (al classpath utilizado al ejecutar las pruebas le falta el directorio de salida de prueba). Sin embargo, no estoy seguro de que esto funcione independientemente de que entiendo que se requiere un corredor de prueba específico de Android.

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 sigues los siguientes 10 minutos, estarás listo para comenzar a agregar tus pruebas a tu propia aplicación. Creo que te sorprenderá lo fácil que es. Yo ciertamente lo era.

Introducción a Android Testing

Hay dos tipos diferentes de pruebas que hará.

  • Pruebas unitarias locales. Estos se ejecutan localmente en JVM (Java Virtual Machine). 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 mocking . Un Context simulado es 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.

Crea un nuevo proyecto y verás las siguientes carpetas predeterminadas.

Todo ya está allí y esperando que crees tus pruebas. ¡Ya está todo listo!

Cómo crear pruebas de unidades locales

Abra el archivo ExampleUnitTest 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 doble verde para ejecutar todas las pruebas o la flecha verde para ejecutar solo una. (En este caso, solo hay una prueba, por lo que ambos hacen lo mismo).

Debería pasar (siempre que 2 + 2 siga siendo 4 cuando esté leyendo esta respuesta). ¡Felicitaciones, acabas de realizar tu primera prueba!

Hacer 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 método addition_isCorrect() 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útalo de nuevo y deberías verlo pasar. Felicitaciones, ¡acabas de crear tu 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 archivo ExampleInstrumentedTest . 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()); } }

Presione 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, acabas de ejecutar tu primera prueba instrumentada!

Hacer tu propia prueba

Las pruebas instrumentadas usan Espresso para ejecutar las pruebas. Es como si tu propio pequeño robot usuario pudieras probar tu aplicación. Puede decirle que haga algo así como presionar un botón o leer las propiedades de un TextView.

Puede escribir las instrucciones de cómo realizar la prueba a mano, pero como recién estamos empezando, usemos la función de grabación automática . Es super simple

Primero agregue un botón a su UI 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>

A continuación, presione Ejecutar> Grabar prueba de café expreso en el menú.

Después de que se inicia, haga clic en el botón en el emulador y luego, para finalizar, elija Aceptar en el cuadro de diálogo Grabar. Debe 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()); } }

¡Estupendo! ¡Acabas de crear tu primera prueba instrumentada! Eso fue súper fácil. Probablemente deberías 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 miraba los videos y luego leía la documentación. Todo es bastante útil. El último enlace es una serie de artículos que cubren algunas cosas importantes para pensar al elegir qué probar.

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

  1. Crea una carpeta en la que escribirás todas tus pruebas unitarias (preferiblemente com.example.app.tests)
  2. Crear una nueva clase de prueba (preferiblemente NameOfClassTestedTests, es decir, BankAccountLoginActivityTests)
  3. Extienda InstrumentationTestCase
  4. Escriba una prueba de unidad fallida para asegurarse de que hemos tenido éxito al configurar 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 Android Tests
  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 el paquete" (generalmente desea 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 desde el menú Ejecutar
  18. Haga clic en Ejecutar y lea los resultados en la consola de salida

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

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. Presione "Sync Project with Gradle file" (en el panel superior). Debería ver ahora que una carpeta "java" (dentro de "prueba de Android") es de color verde.

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

Uno de los cambios más importantes parece ser 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. Android Gradle Guía del usuario

Android Studio v.2.3.3

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

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

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