Thread.sleep( ) con Espresso

Espresso afirma que no hay necesidad de Thread.sleep() pero mi código no funciona a menos que lo incluya. Me estoy conectando a una IP y, mientras me conecto, se muestra un diálogo de progreso. necesito un Thread.sleep() llamar para esperar a que se cierre el cuadro de diálogo. Este es mi código de prueba donde lo uso:

    IP.enterIP(); // fills out an IP dialog (this is done with espresso)

    //progress dialog is now shown
    Thread.sleep(1500);

    onView(withId(R.id.button).perform(click());

He probado este código sin el Thread.sleep() llama pero dice R.id.Button no existe La única forma en que puedo hacer que funcione es con el Thread.sleep() llamada.

Además, he intentado reemplazar Thread.sleep() con cosas como getInstrumentation().waitForIdleSync() y todavía sin suerte.

¿Es esta la única manera de hacer esto? ¿O me estoy perdiendo algo?

En mi mente, el enfoque correcto será:

/** Perform action of waiting for a specific view id. */
public static ViewAction waitId(final int viewId, final long millis) {
    return new ViewAction() {
        @Override
        public Matcher<View> getConstraints() {
            return isRoot();
        }

        @Override
        public String getDescription() {
            return "wait for a specific view with id <" + viewId + "> during " + millis + " millis.";
        }

        @Override
        public void perform(final UiController uiController, final View view) {
            uiController.loopMainThreadUntilIdle();
            final long startTime = System.currentTimeMillis();
            final long endTime = startTime + millis;
            final Matcher<View> viewMatcher = withId(viewId);

            do {
                for (View child : TreeIterables.breadthFirstViewTraversal(view)) {
                    // found view with required ID
                    if (viewMatcher.matches(child)) {
                        return;
                    }
                }

                uiController.loopMainThreadForAtLeast(50);
            }
            while (System.currentTimeMillis() < endTime);

            // timeout happens
            throw new PerformException.Builder()
                    .withActionDescription(this.getDescription())
                    .withViewDescription(HumanReadables.describe(view))
                    .withCause(new TimeoutException())
                    .build();
        }
    };
}

Y luego el patrón de uso será:

// wait during 15 seconds for a view
onView(isRoot()).perform(waitId(R.id.dialogEditor, TimeUnit.SECONDS.toMillis(15)));

Gracias a AlexK por su increíble respuesta. Hay casos en los que necesita hacer algún retraso en el código. No necesariamente está esperando la respuesta del servidor, pero podría estar esperando que se realice la animación. Personalmente, tengo un problema con Espresso idolingResources (creo que estamos escribiendo muchas líneas de código para algo simple), así que cambié la forma en que AlexK estaba haciendo el siguiente código:

/**
 * Perform action of waiting for a specific time.
 */
public static ViewAction waitFor(final long millis) {
    return new ViewAction() {
        @Override
        public Matcher<View> getConstraints() {
            return isRoot();
        }

        @Override
        public String getDescription() {
            return "Wait for " + millis + " milliseconds.";
        }

        @Override
        public void perform(UiController uiController, final View view) {
            uiController.loopMainThreadForAtLeast(millis);
        }
    };
}

Así que puedes crear un Delay class y coloque este método en él para acceder a él fácilmente. Puede usarlo en su clase de prueba de la misma manera: onView(isRoot()).perform(waitFor(5000));

Me topé con este hilo cuando buscaba una respuesta a un problema similar en el que estaba esperando una respuesta del servidor y cambiando la visibilidad de los elementos según la respuesta.

Si bien la solución anterior definitivamente ayudó, finalmente encontré este excelente ejemplo de chiuki y ahora uso ese enfoque como mi recurso cuando estoy esperando que ocurran acciones durante los períodos de inactividad de la aplicación.

he añadido ElapsedTimeIdlingResource() a mi propia clase de utilidades, ahora puedo usarlo de manera efectiva como una alternativa adecuada para Espresso, y ahora el uso es agradable y limpio:

// Make sure Espresso does not time out
IdlingPolicies.setMasterPolicyTimeout(waitingTime * 2, TimeUnit.MILLISECONDS);
IdlingPolicies.setIdlingResourceTimeout(waitingTime * 2, TimeUnit.MILLISECONDS);

// Now we wait
IdlingResource idlingResource = new ElapsedTimeIdlingResource(waitingTime);
Espresso.registerIdlingResources(idlingResource);

// Stop and verify
onView(withId(R.id.toggle_button))
    .check(matches(withText(R.string.stop)))
    .perform(click());
onView(withId(R.id.result))
    .check(matches(withText(success ? R.string.success: R.string.failure)));

// Clean up
Espresso.unregisterIdlingResources(idlingResource);

Creo que es más fácil agregar esta línea:

SystemClock.sleep(1500);

Espera un número dado de milisegundos (de uptimeMillis) antes de regresar. Similar a sleep(largo), pero no arroja InterruptedException; Los eventos de interrupción () se difieren hasta la siguiente operación interrumpible. No regresa hasta que haya transcurrido al menos el número especificado de milisegundos.

Esto es similar a esta respuesta, pero usa un tiempo de espera en lugar de intentos y se puede encadenar con otras ViewInteractions:

/**
 * Wait for view to be visible
 */
fun ViewInteraction.waitUntilVisible(timeout: Long): ViewInteraction {
    val startTime = System.currentTimeMillis()
    val endTime = startTime + timeout

    do {
        try {
            check(matches(isDisplayed()))
            return this
        } catch (e: AssertionFailedError) {
            Thread.sleep(50)
        }
    } while (System.currentTimeMillis() < endTime)

    throw TimeoutException()
}

Uso:

onView(withId(R.id.whatever))
    .waitUntilVisible(5000)
    .perform(click())

Puedes usar los métodos de Barista:

BaristaSleepActions.sleep(2000);

BaristaSleepActions.sleep(2, SECONDS);

Barista es una biblioteca que envuelve Espresso para evitar agregar todo el código que necesita la respuesta aceptada. ¡Y aquí hay un enlace! https://github.com/SchibstedSpain/Barista

Soy nuevo en la codificación y Espresso, así que aunque sé que la solución buena y razonable es usar el ralentí, todavía no soy lo suficientemente inteligente como para hacerlo.

Sin embargo, hasta que tenga más conocimientos, todavía necesito que mis pruebas se ejecuten de alguna manera, así que por ahora estoy usando esta solución sucia que hace varios intentos para encontrar un elemento, se detiene si lo encuentra y, si no lo encuentra, duerme brevemente y comienza nuevamente hasta alcanzar el número máximo de intentos (el mayor número de intentos hasta ahora ha sido alrededor de 150).

private static boolean waitForElementUntilDisplayed(ViewInteraction element) {
    int i = 0;
    while (i++ < ATTEMPTS) {
        try {
            element.check(matches(isDisplayed()));
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            try {
                Thread.sleep(WAITING_TIME);
            } catch (Exception e1) {
                e.printStackTrace();
            }
        }
    }
    return false;
}

Estoy usando esto en todos los métodos que buscan elementos por ID, texto, padre, etc.:

static ViewInteraction findById(int itemId) {
    ViewInteraction element = onView(withId(itemId));
    waitForElementUntilDisplayed(element);
    return element;
}