Espresso Web

Espresso-Web é um ponto de entrada para trabalhar com componentes de IU do Android WebView. O Espresso-Web reutiliza Atoms da conhecida API WebDriver (em inglês) para examinar e controlar o comportamento de um WebView.

Quando usar o Espresso-Web

Use o Espresso-Web para testar seus apps híbridos, especialmente a integração dos componentes de interface nativos do app com os componentes de interface WebView. É possível usar a API Espresso-Web em conjunto com outras APIs Espresso para interagir totalmente com elementos da Web dentro de objetos WebView.

Se você precisar testar apenas o WebView em si, e não as interações entre o WebView e os componentes nativos no app, considere escrever um teste geral da Web usando um framework como o WebDriver. Se você usar um framework de teste da Web, não precisará usar um dispositivo Android ou uma máquina virtual Java, o que torna os testes mais rápidos e confiáveis. Dito isso, o Espresso-Web permite reutilizar seus átomos personalizados do WebDriver, o que oferece muita flexibilidade, especialmente ao escrever testes que você planeja executar em apps da Web independentes e apps que incluem uma IU do Android.

Como funciona

De forma semelhante ao método onData() do Espresso, uma interação WebView é composta por vários Atoms. As interações do WebView usam uma combinação da linguagem de programação Java e uma ponte JavaScript para realizar o trabalho. Como não há chance de introduzir disputas ao expor dados do ambiente JavaScript (tudo que o Espresso vê no lado baseado em Java é uma cópia isolada), o retorno de dados de objetos Web.WebInteraction é totalmente compatível, permitindo que você verifique todos os dados retornados de uma solicitação.

O que é um Atom do WebDriver?

O framework do WebDriver usa Atoms para encontrar e manipular elementos da Web de forma programática. Os Atoms são usados pelo WebDriver para permitir a manipulação do navegador. Um Atom é conceitualmente semelhante a um ViewAction, uma unidade independente que executa uma ação na interface. Você expõe os Atoms usando uma lista de métodos definidos, como findElement() e getElement(), para controlar o navegador do ponto de vista do usuário. No entanto, se você usar o framework WebDriver diretamente, os Atoms precisarão ser devidamente orquestrados, o que exige uma lógica bastante detalhada.

No Espresso, as classes Web e Web.WebInteraction (no pacote androidx.test.espresso.web.sugar) encapsulam esse código boilerplate e dão uma sensação semelhante ao Espresso ao interagir com objetos WebView. Portanto, no contexto de um WebView, os Atoms são usados como uma substituição para os ViewMatchers e ViewActions tradicionais do Espresso. Consulte a página de referência do Espresso (link em inglês) para ver as correspondências e ações padrão.

A API é bastante simples:

onWebView()
    .withElement(Atom)
    .perform(Atom)
    .check(WebAssertion)

Para saber mais, leia a documentação do Selenium sobre Atoms (em inglês).

Implementar o WebView

Siga as orientações mostradas nas seções a seguir para trabalhar com WebView nos testes do app.

Pacotes

Para incluir o Espresso-Web no projeto, siga estas etapas:

  1. Abra o arquivo build.gradle do seu app. Geralmente, esse não é o arquivo build.gradle de nível superior, mas app/build.gradle.
  2. Adicione a seguinte linha nas dependências:

    Groovy

        androidTestImplementation 'androidx.test.espresso:espresso-web:3.6.1'
        

    Kotlin

        androidTestImplementation('androidx.test.espresso:espresso-web:3.6.1')
        
  3. O Espresso-Web é compatível apenas com o Espresso 2.2 ou mais recente e com a versão 0.3 ou mais recente da biblioteca de testes. Portanto, atualize também estas linhas:

    Groovy

        androidTestImplementation 'androidx.test:runner:1.6.1'
        androidTestImplementation 'androidx.test:rules:1.6.1'
        androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1'
        

    Kotlin

        androidTestImplementation('androidx.test:runner:1.6.1')
        androidTestImplementation('androidx.test:rules:1.6.1')
        androidTestImplementation('androidx.test.espresso:espresso-core:3.6.1')
        

Uso comum da API

O método onWebView() é o principal ponto de entrada ao trabalhar com WebView no Android usando o Espresso. Use esse método para realizar testes do Espresso-Web, como:

onWebView()
    .withElement(findElement(Locator.ID, "link_2")) // similar to onView(withId(...)).
    .perform(webClick()) // Similar to perform(click()).
    // Similar to check(matches(...)).
    .check(webMatches(getCurrentUrl(), containsString("navigation_2.html")))

Neste exemplo, o Espresso-Web localiza um elemento DOM com o ID "link_2" e clica nele. Em seguida, a ferramenta verifica se a WebView envia uma solicitação GET contendo a string "navigation_2.html".

Compatibilidade com JavaScript

Ao executar os testes, o sistema realiza todas as interações da WebView usando JavaScript. Portanto, para oferecer suporte à avaliação de JavaScript, a WebView em teste precisa ter o JavaScript ativado.

Para forçar a ativação do JavaScript, chame forceJavascriptEnabled() como uma ação na atividade em teste, conforme mostrado no snippet de código abaixo.

@RunWith(AndroidJUnit4::class)
class MyTestSuite {
    @get:Rule val activityScenarioRule =
        activityScenarioRule<MyWebViewActivity>()

    @Test fun testWebViewInteraction() {
        onWebView().forceJavascriptEnabled()
    }
}

Interações comuns na Web

As interações comuns com objetos Web.WebInteraction incluem o seguinte:

  • withElement() faz referência a um elemento DOM dentro do WebView.

    Exemplo:

    onWebView().withElement(findElement(Locator.ID, "teacher"))
  • withContextualElement() faz referência a um elemento DOM com escopo na WebView, em relação a outro elemento DOM. Chame withElement() primeiro para estabelecer o objeto Web.WebInteraction de referência (elemento DOM).

    Exemplo:

    .withElement(findElement(Locator.ID, "teacher"))
    .withContextualElement(findElement(Locator.ID, "person_name"))
  • check() avalia uma condição, garantindo que ela seja resolvida como true.

    Exemplo:

    onWebView()
        .withElement(findElement(Locator.ID, "teacher"))
        .withContextualElement(findElement(Locator.ID, "person_name"))
        .check(webMatches(getText(), containsString("Socrates")))
  • perform() executa uma ação em um WebView, como clicar em um elemento.

    Exemplo:

    onWebView()
        .withElement(findElement(Locator.ID, "teacher"))
        .perform(webClick())
  • reset() reverte o WebView para o estado inicial. Isso é necessário quando uma ação anterior, como um clique, introduz uma mudança de navegação que torna os objetos ElementReference e WindowReference inacessíveis.

    Observação: embora o uso de reset() seja útil ao fazer declarações em fluxos de trabalho de várias páginas, como envios de formulários, seus testes geralmente devem ser limitados em escopo e se concentrar em uma única página.

    Exemplo:

    onWebView()
        .withElement(...)
        .perform(...)
        .reset()

Exemplo

O exemplo a seguir testa se, depois de inserir texto em uma WebView e selecionar um botão Submit, o mesmo texto aparece em um elemento diferente na mesma WebView:

const val MACCHIATO = "Macchiato"

@RunWith(AndroidJUnit4::class)
class MyEspressoWebTestSuite {

    @Test fun typeTextInInput_clickButton_SubmitsForm() {
        // Create an intent that displays a web form.
        val webFormIntent = Intent()
        // ...

        // Lazily launch the Activity with a custom start Intent per test.
        ActivityScenario.launch<MyWebViewActivity>(webFormIntent)

        // Selects the WebView in your layout. If you have multiple WebView
        // objects, you can also use a matcher to select a given WebView,
        // onWebView(withId(R.id.web_view)).
        onWebView()
            // Find the input element by ID.
            .withElement(findElement(Locator.ID, "text_input"))
            // Clear previous input and enter new text into the input element.
            .perform(clearElement())
            .perform(DriverAtoms.webKeys(MACCHIATO))
            // Find the "Submit" button and simulate a click using JavaScript.
            .withElement(findElement(Locator.ID, "submitBtn"))
            .perform(webClick())
            // Find the response element by ID, and verify that it contains the
            // entered text.
            .withElement(findElement(Locator.ID, "response"))
            .check(webMatches(getText(), containsString(MACCHIATO)))
    }
}

Outros recursos

Para mais informações sobre o uso do Espresso-Web em testes do Android, consulte os recursos abaixo.

Amostras

  • WebBasicSample: use o Espresso-Web para interagir com objetos WebView.