Esta resposta é para pessoas que estão apenas começando com os testes do Android. Fornecerei dois exemplos simples para ajudá-lo a ver como funcionam os testes. Se você acompanhar pelos próximos 10 minutos, estará tudo pronto para começar a adicionar seus testes ao seu próprio aplicativo. Acho que você ficará surpreso com o quão fácil é. Eu certamente estava.
Introdução ao Android Testing
Existem dois tipos diferentes de testes que você fará.
- Testes de unidade local. Eles são executados localmente na JVM (Java Virtual Machine). Por serem locais, são rápidos. Você pode usá-los para testar as partes do seu código que precisam apenas do Java e não das APIs do Android. (Às vezes, você pode fazer um objeto de API falso para testar mais coisas localmente. Isso é chamado de simulação . Uma simulação
Contexté um exemplo.)
- Testes instrumentados. Esses testes são executados em um dispositivo real ou no emulador. Isso os torna mais lentos do que os testes locais. No entanto, eles são mais flexíveis porque você tem a API Android completa disponível para você.
Crie um novo projeto e você verá as seguintes pastas padrão.
Tudo já está aí e esperando por você para criar seus testes. Já está tudo configurado!
Como criar testes de unidade locais
Abra o ExampleUnitTestarquivo mostrado na imagem acima. deve ser parecido com isto:
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
assertEquals(4, 2 + 2);
}
}
Pressione a seta verde dupla para executar todos os testes ou a seta verde única para executar apenas um. (Neste caso, há apenas um teste, então ambos fazem a mesma coisa.)
Deve passar (contanto que 2 + 2ainda esteja 4quando você estiver lendo esta resposta). Parabéns, você acabou de fazer seu primeiro teste!
Fazendo seu próprio teste
Vamos escrever nosso próprio teste. Primeiro adicione esta classe ao seu projeto de aplicativo principal para que tenhamos algo para testar:
public class MyClass {
public int add(int a, int b) {
return a + b;
}
}
Agora mude o addition_isCorrect()método na classe de teste para ficar como o código a seguir (ou apenas adicione outro método com um nome diferente):
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
MyClass myClass = new MyClass();
int result = myClass.add(2, 2);
int expected = 4;
assertEquals(expected, result);
}
}
Execute-o novamente e você verá que passa. Parabéns, você acabou de criar seu primeiro teste! (Bem, acho que tecnicamente era meu, mas, ei, perto o suficiente. O que é meu é seu.)
Como criar testes instrumentados
Abra o ExampleInstrumentedTestarquivo. deve ser parecido com isto:
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() throws Exception {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getTargetContext();
assertEquals("com.example.myapp", appContext.getPackageName());
}
}
Pressione um desses botões verdes novamente.
Contanto que você tenha um dispositivo real conectado ou o emulador configurado, ele deve ter inicializado e executado seu aplicativo. Parabéns, você acabou de executar seu primeiro teste instrumentado!
Fazendo seu próprio teste
Os testes instrumentados usam o Espresso para executar os testes. É como se fosse seu próprio pequeno usuário de robô que você pode mandar testar seu aplicativo. Você pode dizer a ele para fazer algo como pressionar um botão ou ler as propriedades de um TextView.
Você pode escrever as instruções de como fazer o teste manualmente, mas como estamos apenas começando, vamos usar a função de gravação automática . É super simples.
Primeiro adicione um botão à sua IU para que tenhamos algo com que trabalhar. Eu fiz isso:
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.example.myapp.MainActivity">
<Button
android:id="@+id/myButton"
android:text="Click me"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
</android.support.constraint.ConstraintLayout>
Em seguida, pressione Executar> Gravar teste Espresso no menu.
Depois de iniciar, clique no botão no emulador e, para finalizar, escolha OK na caixa de diálogo Registro. Ele deve gerar automaticamente o seguinte código de teste.
@LargeTest
@RunWith(AndroidJUnit4.class)
public class MainActivityTest {
@Rule
public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);
@Test
public void mainActivityTest() {
ViewInteraction appCompatButton = onView(
allOf(withId(R.id.myButton), withText("Click me"), isDisplayed()));
appCompatButton.perform(click());
}
}
Ótimo! Você acabou de criar seu primeiro teste instrumentado! Isso foi super fácil. Você provavelmente deve adicionar uma afirmação para torná-lo um teste real, mas isso também é muito fácil de fazer com o gravador. Assista a este vídeo para se aprofundar um pouco mais.
Um estudo mais aprofundado
Eu primeiro assistia aos vídeos e depois lia a documentação. É tudo muito útil. O último link é para uma série de artigos que cobrem algumas coisas importantes para se pensar ao escolher o que testar.
