support - test ui android

Android Espresso Tests para teléfono y tableta

Question

Mi configuración: - Aplicación de Android con versión para teléfono y tableta - Estoy usando Android Espresso para UI-Tests (ahora solo para versión para teléfono, con teléfono en buildagent)

Lo que quiero hacer: - Ahora quiero que Espresso distinga entre las pruebas para el teléfono y la tableta - Así que la Prueba A solo debe ejecutarse con una tableta, la Prueba B solo con un teléfono y la Prueba C ambas - Las pruebas deben ser ejecutables a través de tarea de gradle

Answer 1

Sé que la pregunta es un poco vieja, pero pensé en publicarla ya que esta es una forma un poco más simple.
Así que simplemente ponga un valor booleano para el tamaño de pantalla objetivo -
for ex values-sw600dp.xml para tablet y values.xml para teléfono. Pon un valor booleano en ambos
por ejemplo en values.xml -

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="tablet">false</bool>
</resources>

y en los values-sw600.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="tablet">true</bool>
</resources>

Luego, en la clase Prueba, use esto para obtener el valor del recurso.

Context targetContext = InstrumentationRegistry.getTargetContext();
targetContext.getResources().getBoolean(R.bool.tablet);
Boolean isTabletUsed = targetContext.getResources().getBoolean(R.bool.tablet);

Answer 2

Tres opciones, todas ejecutables a través de las gradlew connectedAndroidTest o custom gradle:

1. Utilice org.junit.Assume

De Supuestos con asumir - junit-team / junit Wiki - Github :

El corredor de JUnit predeterminado trata las pruebas con suposiciones fallidas como ignoradas. Los corredores personalizados pueden comportarse de manera diferente.

Desafortunadamente, el com.android.support.test:runner:0.2 android.support.test.runner.AndroidJUnit4 ( com.android.support.test:runner:0.2 ) trata las suposiciones fallidas como pruebas fallidas.

Una vez que se arregle este comportamiento, lo siguiente funcionaría (vea la opción 3 a continuación para la fuente isScreenSw600dp() ):

Sólo teléfono: todos los métodos de prueba en la clase

    @Before
    public void setUp() throws Exception {
        assumeTrue(!isScreenSw600dp());
        // other setup
    }

Métodos de prueba específicos

    @Test
    public void testA() {
        assumeTrue(!isScreenSw600dp());
        // test for phone only
    }

    @Test
    public void testB() {
        assumeTrue(isScreenSw600dp());
        // test for tablet only
    }

2. Usa una regla de JUnit personalizada

De una regla de JUnit para ignorar condicionalmente las pruebas :

Esto nos llevó a crear una anotación ConditionalIgnore y una regla correspondiente para conectarla al tiempo de ejecución de JUnit. La cosa es simple y se explica mejor con un ejemplo:

public class SomeTest {
  @Rule
  public ConditionalIgnoreRule rule = new ConditionalIgnoreRule();

  @Test
  @ConditionalIgnore( condition = NotRunningOnWindows.class )
  public void testFocus() {
    // ...
  }
}

public class NotRunningOnWindows implements IgnoreCondition {
  public boolean isSatisfied() {
    return !System.getProperty( "os.name" ).startsWith( "Windows" );
  }
}

ConditionalIgnoreRule código aquí: JUnit regla para ignorar condicionalmente los casos de prueba .

Este enfoque se puede modificar fácilmente para implementar el método isScreenSw600dp() en la Opción 3 a continuación.

3. Usar condicionales en los métodos de prueba.

Esta es la opción menos elegante, especialmente porque las pruebas omitidas en su totalidad se informarán como aprobadas, pero es muy fácil de implementar. Aquí hay una clase de prueba de muestra completa para comenzar:

import android.support.test.InstrumentationRegistry;
import android.support.test.runner.AndroidJUnit4;
import android.test.ActivityInstrumentationTestCase2;
import android.util.DisplayMetrics;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import static android.support.test.espresso.Espresso.onView;
import static android.support.test.espresso.assertion.ViewAssertions.matches;
import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
import static android.support.test.espresso.matcher.ViewMatchers.withId;

@RunWith(AndroidJUnit4.class)
public class DeleteMeTest extends ActivityInstrumentationTestCase2<MainActivity> {
    private MainActivity mActivity;
    private boolean mIsScreenSw600dp;

    public DeleteMeTest() {
        super(MainActivity.class);
    }

    @Before
    public void setUp() throws Exception {
        injectInstrumentation(InstrumentationRegistry.getInstrumentation());
        setActivityInitialTouchMode(false);
        mActivity = this.getActivity();
        mIsScreenSw600dp = isScreenSw600dp();
    }

    @After
    public void tearDown() throws Exception {
        mActivity.finish();
    }

    @Test
    public void testPreconditions() {
        onView(withId(R.id.your_view_here))
                .check(matches(isDisplayed()));
    }

    @Test
    public void testA() {
        if (!mIsScreenSw600dp) {
            // test for phone only
        }
    }

    @Test
    public void testB() {
        if (mIsScreenSw600dp) {
            // test for tablet only
        }
    }

    @Test
    public void testC() {
        if (mIsScreenSw600dp) {
            // test for tablet only
        } else {
            // test for phone only
        }

        // test for both phone and tablet
    }

    private boolean isScreenSw600dp() {
        DisplayMetrics displayMetrics = new DisplayMetrics();
        mActivity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
        float widthDp = displayMetrics.widthPixels / displayMetrics.density;
        float heightDp = displayMetrics.heightPixels / displayMetrics.density;
        float screenSw = Math.min(widthDp, heightDp);
        return screenSw >= 600;
    }
}