Multiprocess Espresso

À medida que seu app cresce, pode ser útil colocar alguns dos componentes do app em um processo diferente do processo principal. Para testar os componentes do app nesses processos não padrão, use a funcionalidade Multiprocess Espresso. Essa ferramenta, disponível no Android 8.0 (nível 26 da API) e versões mais recentes, permite testar com facilidade as interações de interface do seu app que ultrapassam os limites de processo, mantendo as garantias de sincronização do Espresso.

Ao usar o Multiprocess Espresso, lembre-se das seguintes considerações sobre controle de versões e escopo:

  • O app precisa segmentar o Android 8.0 (API nível 26) ou posterior.
  • A ferramenta só pode testar os componentes do app que você inclui nos processos dentro do pacote do app. Ela não pode testar processos externos.

Usar a ferramenta

Para testar um processo no app usando o Multiprocess Espresso, adicione uma referência ao artefato espresso-remote no arquivo build.gradle do app:

app/build.gradle

Groovy

dependencies {
    ...
    androidTestImplementation 'androidx.test.espresso:espresso-remote:3.4.0'
}

Kotlin

dependencies {
    ...
    androidTestImplementation('androidx.test.espresso:espresso-remote:3.4.0')
}

Também é necessário adicionar o seguinte ao manifesto androidTest do app:

  • Um elemento <instrumentation> que define o processo.
  • Um elemento <meta-data> que indica o uso do Multiprocess Espresso.

O snippet de código a seguir mostra como adicionar esses elementos:

src/androidTest/AndroidManifest.xml

<manifest ... package="androidx.test.mytestapp.tests">
  <uses-sdk android:targetSdkVersion="27" android:minSdkVersion="14" />
  <instrumentation
    android:name="androidx.test.runner.AndroidJUnitRunner"
    android:targetPackage="androidx.test.mytestapp"
    android:targetProcesses="*">
    <meta-data
      android:name="remoteMethod"
      android:value="androidx.test.espresso.remote.EspressoRemote#remoteInit" />
  </instrumentation>
</manifest>

O snippet anterior indica ao framework do Android que você quer que ele teste cada processo no pacote do app. Para testar apenas um subconjunto dos processos do app, especifique uma lista separada por vírgulas no elemento targetProcesses:

<instrumentation
    ...
    android:targetProcesses=
            "androidx.test.mytestapp:myFirstAppProcessToTest,
             androidx.test.mytestapp:mySecondAppProcessToTest" ... />

Compreender a arquitetura da ferramenta

Ao testar o app e iniciar o processo padrão, é possível realizar uma interação de interface, como o pressionamento de um botão, que inicia uma atividade em um processo secundário. Em seguida, o sistema conclui as etapas abaixo para ativar o teste entre processos usando o Espresso:

  1. O framework do Android cria e inicia um novo processo para seguir a estrutura de navegação do seu app. Cada processo Instrumentation inclui uma nova instância de AndroidJUnitRunner. Nesta fase, os dois processos de instrumentação não podem se comunicar entre si.
  2. Cada instância de AndroidJUnitRunner registra o Espresso como o framework de teste.
  3. As duas instâncias de AndroidJUnitRunner realizam um handshake para estabelecer uma conexão entre si. Ao mesmo tempo, cada instância de AndroidJUnitRunner conecta todos os clientes registrados, como o Espresso, com os respectivos equivalentes em outros processos, para que esses clientes possam formar um canal de comunicação direta entre si.
  4. Cada instância de AndroidJUnitRunner continua procurando instâncias de instrumentação recém-adicionadas e clientes de framework de teste, estabelecendo outros canais de comunicação, conforme necessário.

A Figura 1 ilustra o resultado desse processo:

Figura 1. Como estabelecer a comunicação entre vários processos de instrumentação usando o Multiprocess Espresso.

Outros recursos

Para saber mais sobre esse assunto, consulte os recursos a seguir.