No artigo de hoje, veremos como é possível gerar um relatório de cobertura de testes em um projeto Android incluindo tanto os testes unitários (geralmente escritos com JUnit, Mockito, Robolectric etc.) quanto os instrumentados (geralmente escritos utilizando o Espresso).

Relatórios de cobertura são uma ferramenta muito importante para mensurar o quanto nossos testes realmente exercitam nosso código. Apesar de não serem a garantia de um software sem bugs, ter uma porcentagem alta de cobertura pode evitar muitas dores de cabeça no desenrolar do projeto.

No Android, para gerar esse tipo de relatório utilizamos o Jacoco (Java Code Coverage), uma das ferramentas mais utilizadas dentro do Java para esse propósito. No ambiente de desenvolvimento do Android, temos um fator dificultador que é o fato de possuirmos dois artefatos de teste diferentes, geralmente representados pelas pastas test (unitários) e androidTest (instrumentados).

Primeiramente, vamos gerar o relatório de cobertura dos testes instrumentados do Espresso. Para este exemplo, teremos uma Activity bem simples:

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
 
    private TextView text;
 
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        findViewById(R.id.button).setOnClickListener(this);
        findViewById(R.id.hide).setOnClickListener(this);
        text = (TextView) findViewById(R.id.text);
    }
 
    @Override
    public void onClick(View v) {
        if (v.getId() == R.id.button) {
            text.setText("Hello World!");
        } else {
            v.setVisibility(View.GONE);
        }
    }
}

O layout dessa Activity é o seguinte:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
 
    <TextView
        android:id="@+id/text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello" />
 
    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Click Me!" />
 
    <Button
        android:id="@+id/hide"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Don't Click Me!" />
 
</LinearLayout>

Vamos, então, criar um teste no Espresso para garantir que o texto do TextView text seja modificado para Hello World! ao clicarmos no Button button:

@RunWith(AndroidJUnit4.class)
@LargeTest
public class MainActivityTest {
 
    @Rule
    public ActivityTestRule<MainActivity> rule = new ActivityTestRule<>(MainActivity.class);
 
    @Test
    public void shouldUpdateTextAfterButtonClick() {
        onView(withId(R.id.button)).perform(click());
 
        onView(withId(R.id.text)).check(matches(withText("Hello World!")));
    }
}

Após a execução desse teste, temos o relatório de execução:

Porém, o relatório de cobertura ainda não é gerado. Para habilitarmos essa opção, precisamos adicionar uma propriedade para a nossa build variant de debug. Na DSL do plugin do Android, habilite a cobertura por meio da propriedade testCoverageEnabled:

android {
    ...
    buildTypes {
        debug {
            testCoverageEnabled true
        }
        ...
    }
}

Agora, basta executar a task createDebugCoverageReport para que os testes sejam executados e o relatório seja gerado.

Perfeito! Já temos o relatório de cobertura do nosso projeto.

Vamos agora usar o Robolectric para criar um teste para o else da lógica da nossa Activity. Porém, um aviso: particularmente, eu não recomendo testar a Activity e componentes do Android diretamente pelo Robolectric. Prefira testes que, de fato, testem unidades de código.

Um teste com Robolectric que testa o comportamento do botão hide, cuja visibilidade é alterada quando clicado, ficaria assim:

@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class, sdk = 21)
public class MainActivityTest {
 
    @Test
    public void shouldHideButtonAfterClick() {
        MainActivity activity = Robolectric.setupActivity(MainActivity.class);
 
        Button button = (Button) activity.findViewById(R.id.hide);
        button.performClick();
 
        assertThat(button.getVisibility(), is(View.GONE));
    }
}

Por padrão, o plugin do Android só gera o relatório de cobertura dos testes instrumentados. Para que seja possível gerar a cobertura dos testes unitários, é necessário criar uma task de execução do relatório manualmente:

apply plugin: 'jacoco'
 
task jacocoTestReport(type: JacocoReport, dependsOn: 'testDebugUnitTest') {
 
    reports {
        xml.enabled = true
        html.enabled = true
    }
 
    jacocoClasspath = configurations['androidJacocoAnt']
 
    def fileFilter = ['**/R.class', '**/R$*.class', '**/BuildConfig.*', '**/Manifest*.*', '**/*Test*.*', 'android/**/*.*']
    def debugTree = fileTree(dir: "${buildDir}/intermediates/classes/debug", excludes: fileFilter)
    def mainSrc = "${project.projectDir}/src/main/java"
 
    sourceDirectories = files([mainSrc])
    classDirectories = files([debugTree])
    executionData = files("${buildDir}/jacoco/testDebugUnitTest.exec")
}

Com a criação da task jacocoTestReport, temos agora a geração do relatório de cobertura também para os testes unitários.

Mas o problema permanece: como ter a cobertura unificada do resultado dos dois grupos de testes?

A instrumentação realizada pelo Jacoco produz arquivos de execução que contém os dados necessários para a criação do relatório (HTML, XML, etc). O grande problema é que o Espresso gera o arquivo .ec, enquanto que a execução dos testes unitários gera o arquivo .exec, ou seja, temos formatos de arquivos diferentes!

E agora? Como converter de um formato para o outro? A resposta, obtida depois de muita pesquisa, é: simplesmente não é necessário converter!

Como não temos acesso à task que configura a execução dos testes com o Espresso, precisamos garantir que ela seja executada primeiro para que, na execução do relatório dos testes unitários, o arquivo coverage.ec já esteja disponível.

Na task do relatório dos testes unitários, o que vamos fazer é adicionar o arquivo coverage.ec também como parâmetro na propriedade executionData:

apply plugin: 'jacoco'
 
task jacocoTestReport(type: JacocoReport, dependsOn: 'testDebugUnitTest') {
 
    reports {
        xml.enabled = true
        html.enabled = true
    }
 
    jacocoClasspath = configurations['androidJacocoAnt']
 
    def fileFilter = ['**/R.class', '**/R$*.class', '**/BuildConfig.*', '**/Manifest*.*', '**/*Test*.*', 'android/**/*.*']
    def debugTree = fileTree(dir: "${buildDir}/intermediates/classes/debug", excludes: fileFilter)
    def mainSrc = "${project.projectDir}/src/main/java"
 
    sourceDirectories = files([mainSrc])
    classDirectories = files([debugTree])
    executionData = files(["${buildDir}/jacoco/testDebugUnitTest.exec",
                           "${buildDir}/outputs/code-coverage/connected/coverage.ec"
    ])
}

Por fim, ao executarmos a task completa, com os testes instrumentados pelo Espresso primeiro, teremos o relatório unificado de cobertura.

gradle clean createDebugCoverageReport jacocoTestReport

E é isso! O projeto de exemplo pode ser encontrado neste repositório do Github!

#KeepCoding #KeepTesting

Ficou alguma dúvida ou tem alguma observação? Deixe seu comentário abaixo e até a próxima!