O que podemos tirar dessa frase é que há momentos que necessitamos parar e tentar trazer uma segurança e qualidade para o nosso código, e acredito que uma das formas de podermos “afiar” nosso “machado” é a prática de testes funcionais e também os testes unitários. Sem sombra de dúvidas.

Neste post irei apresentar a ferramenta Robotium utilizada para criar testes funcionais no Android para garantir maior qualidade para nossos sistemas.

O bacana do Robotium é que está sendo constantemente melhorado, as suas features são liberadas constantemente. Uma que estou bastante ansioso é a de cobertura de código:

Features we want to implement in the future
Automatic measurement of user interface test coverage.

Para quem ainda não sabe o que é teste funcional, conhecido também como teste de caixa preta, consiste em computar o comportamento externo do software, deixando de lado o comportamento interno. Básicamente é dado informações de entrada, processado e esperado um resultado e este resultado é comparado com um previamente esperado.

Exemplo prático, imagine que eu tenha uma tela de login, que deverá possuir 2 campos para serem preenchidos de nome de usuário e senha. Posso validar através do teste funcional desde a presença dos edits, labels e botões.

Vamos pegar esse exemplo da tela de login.

Link do Robotium aqui.

É necessário baixar o .jar do Robotium e adiciona-lo ao projeto de teste.

Primeiramente vamos criar um projeto Android, chamaremos de “TesteComRobotium” e marcaremos o check “Create a Test Project” para ser criado um projeto de testes também.



Vamos pegar o layout main.xml do projeto criado e colocaremos o código a seguir:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Usuário" />

    <EditText
        android:id="@+id/edtUsuario"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >

        <requestFocus />
    </EditText>

    <TextView
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Senha" />

    <EditText
        android:id="@+id/edtSenha"
        android:password="true"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/btnLogar"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Logar" />

</LinearLayout>

//Esta classe irá herdará de uma classe do nosso framework Robotium
public class TesteComRobotiumActivityTest extends ActivityInstrumentationTestCase2<TesteComRobotiumActivity>{

	private Solo solo; //Criada variavel solo que é responsavel por acessar a activity
	
	public TesteComRobotiumActivityTest() {
		super("br.robotium", TesteComRobotiumActivity.class); //Definindo a activity que iremos testar
	}
	
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		solo = new Solo(getInstrumentation(), getActivity());
	}
	
	public void testLogin(){
		assertTrue(solo.searchText("Usuário"));//Irá verificar se existe o texto "Usuário" na tela
		assertTrue(solo.searchText("Senha"));//Irá verificar se existe o texto "Usuário" na tela
	}	
}

public class TesteComRobotiumActivity extends Activity implements OnClickListener{

	private EditText edtUsuario;
	private EditText edtSenha;
	private Button btnLogar;
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        edtUsuario = (EditText) findViewById(R.id.edtUsuario);
    	edtSenha = (EditText) findViewById(R.id.edtSenha);
    	btnLogar = (Button) findViewById(R.id.btnLogar);
    	btnLogar.setOnClickListener(this);
    }
    
    @Override
    public void onClick(View v) {
    	switch (v.getId()) {
		case R.id.btnLogar:
			validarLogin();
			break;
		}
    }

	private void validarLogin() {
		//Caso o usuario seja admin e a senha 123...
		if (edtUsuario.getText().equals("admin") && edtSenha.getText().equals("123")) {
			Toast.makeText(this, "Login realizado com sucesso!", 2000).show();
		}else{
			Toast.makeText(this, "Usuário ou senha incorretos!", 2000).show();
		}
	}
}

         public void testUsuarioESenhaIncorretos(){
		//Estaremos criando os 2 edits para podermos preencher posteriormente...
		EditText edtUsuario = (EditText) solo.getView(br.robotium.R.id.edtUsuario);
		EditText edtSenha = (EditText) solo.getView(br.robotium.R.id.edtSenha);
		
		solo.enterText(edtUsuario, "bla");
		solo.enterText(edtSenha, "bla");
		solo.clickOnButton("Logar");
		assertTrue(solo.searchButton("Usuário ou senha incorretos!")); 	
	}
	
	public void testUsuarioESenhaCorretos(){
		//Estaremos criando os 2 edits para podermos preencher posteriormente...
		EditText edtUsuario = (EditText) solo.getView(br.robotium.R.id.edtUsuario);
		EditText edtSenha = (EditText) solo.getView(br.robotium.R.id.edtSenha);
		
		solo.enterText(edtUsuario, "admin");
		solo.enterText(edtSenha, "123");
		solo.clickOnButton("Logar");
		assertTrue(solo.searchButton("Login realizado com sucesso!")); 	
	}

Bem, essa é uma das possibilidades de melhoria de qualidade de software, não é com ela que poderemos garantir um software 100% funcionando, isento de bugs. Existem algumas brechas para este tipo de teste. Existem vários outros tipos de testes, mas minha opinião o ideal e que acredito que possa trazer grande é fazer a junção de testes funcionais e testes unitários para garantir ainda mais a qualidade do nosso software.

Existem possibilidades a mais para serem testadas com o Robotium, mas o intuito deste post era só apresentar o básico da ferramenta. Em outro momento demonstrarei outros exemplos mais complexos.

Imagine que estamos na ActivityPrincipal e queremos ir para a ActivitySecundaria, onde precisamos passar o valor de uma variável do tipo string chamada nome com o conteúdo “joãozinho”.

Teremos o seguinte:

  String variavelNome = "Joãozinho";
  Intent intent = new Intent(this, ActivitySecundaria.class);
  intent.putExtra("nome", variavelNome);
  startActivity(intent);

Neste trecho de código, podemos ver que estamos criando a variavelNome e atribuindo o valor “Joãozinho” para ela, e logo em seguida instânciamos uma intent com a INTENÇÃO de de passar o valor da variável e depois chamar a outra tela(ActivitySecundaria).

Até aí tudo bem, e na ActivitySecundaria, como devemos fazer?
Nela, precisaremos também criar uma Intent que “capture” o valor do “nome” que despejamos na ActivityPrincipal.
Ficará da seguinte forma:

  Intent intent = getIntent();
  String nome = intent.getStringExtra("nome");

Instanciamos a intent com o getIntent() e logo após chamamos o metodo getStringExtra(“nome”) para capturar o conteúdo que tínhamos passado na tela anterior.
Caso o valor que quiséssemos capturar fosse um double, por exemplo, deveríamos utilizar o método
getDoubleExtra() e se fosse um boolean seria getBooleanExtra() e assim por diante…

Vários projetos de software precisam que determinadas classes possuam apenas uma instância. Como por exemplo um objeto que contém a configuração do sistema.

Podemos ver a modelagem logo abaixo de como ficaria:

Vamos abrir o main.xml, que nada mais é do que o layout principal do nosso aplicativo.

Dando um duplo clique no arquivo main.xml teremos a seguinte visualização:

Podemos notar que no lado esquerdo da imagem a cima temos o “Palette” que é onde ficam os objetos, separados por abas. Logo no canto inferior da imagem podemos observar dois botões, o “Graphical Layout” e o “main.xml”, onde o primeiro podemos visualizar a tela e o segundo visualizar o código xml da tela.

Bem, agora vamos adicionar um botão na tela, temos duas opcões: clicar e arrastar o botão ou digitar na mão o código xml que gere um botão. Vale lembrar que, ao adicionar um botão no estilo drag-drop podemos ver o xml gerado.

Após adicionar o botão, poderemos mudar as propriedades do mesmo, como o nome do botão e o texto que será exibido no botão.

Como podemos ver nas imagens a cima, coloquei o texto a ser exibido no botão de “Proxima Tela”, e o nome do botão de “btnTela2″.

Vamos agora criar uma nova Activity:

E vamos chama-la de Tela2Activity:

Logo após vamos criar um arquivo xml chamado tela2.xml:

E incluiremos um textview no layout, e colocaremos a propriedade text dele de “Tela 2″.

Feito isso, vamos dar acão para o botão na activity principal do projeto.

import br.com.R.id;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import br.com.Tela2Activity;

public class ProjetoAndroidActivity extends Activity {
//Criando uma variável chamada botao2 e referenciando ela ao botão btnTela2.
	Button botao2 = (Button) findViewById(id.btnTela2);	
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

//desenhando a view main na activity corrente.
        setContentView(R.layout.main);

//Implementando uma acão no botao2.
        botao2.setOnClickListener(new OnClickListener() {			
			@Override
			public void onClick(View v) {
//Criando uma intent, onde iremos dizer para onde essa "intenção" irá.
				Intent it = new Intent(ProjetoAndroidActivity.this, Tela2Activity.class);
//Funcão para dar inicio a intent.
	  		    startActivity(it);
			}
		});

    }
}

Agora vamos na activity da Tela 2 e vamos mandar ela desenhar o layout respectivo.

import android.app.Activity;
import android.os.Bundle;

public class Tela2Activity extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
//desenhando a tela2.xml
		setContentView(R.layout.tela2);
	}
}

E por ultimo precisamos declarar no arquivo AndroidManifest.xml a activity criada.
Vale salientar que todo e qualquer criacão de Activity deverá ser declara no AndroidManifest, para quem programa em Java Web, esse arquivo tem a mesma finalidade que o web.xml.


Clicando no botão “AndroidManifest.xml” para que podemos adicionar o xml abaixo:

<activity android:name=".Tela2Activity"/>    

E o AndroidManifest ficará assim:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="br.com"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:minSdkVersion="8" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:label="@string/app_name"
            android:name=".ProjetoAndroidActivity" >
            <intent-filter >
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        
        <activity android:name=".Tela2Activity"/>    
    </application>

</manifest>

E agora é só rodar o aplicativo…

Bem, primeiramente precisaremos criar um projeto:

Preencheremos o nome do projeto…

Selecionaremos a versão do Android (selecionei a 2.2)

E por ultimo preencher o package.

Logo após finalizar será criado o projeto que conterá esses arquivos:

Vamos rodar o projeto e ver o que vai aparecer. Clicando com o botão direito em cima do projeto criado vamos em Run as > Android application.

Após fazer mandar rodar o app irá abrir uma janela, esta janela é a máquina virtual que já irá mostrar a aplicação. Um “hello world” padrão.

É responsável por receber os “anúncios” do sistema. Durante seu funcionamento, o Android executa vários eventos, como por exemplo o recebimento de mensagens(sms), alteração de configurações, etc. Quando um desses eventos ocorre, o Android envia um “anúncio” em broadcast para todas as aplicações do aparelho que possam vir a desejar recebe-la, porém o sistema não é o único que pode enviar esses anúncios, é possível também que outras aplicações possam vir a fazê-lo.

É uma forma interessante e agradável de informar ao usuário que alguma mensagem de alguma aplicação está ativa no momento.
Nesta notificação o usuário pode visualizar o seu conteúdo ou simplesmente ignora-lo. Para visualização da notificação pode-se disparar uma intent para iniciar algum recurso ou processo diferente.

É uma forma de criar componentes específicos para aplicações que precisem utilizar operações que possam demorar, evitando assim que o gerenciador do sistema operacional não destrua o processo e também que possuam funcionalidadesque executem de modo invisível, sem a interação do usuário.

Os padrões de design podem acelerar o processo de desenvolvimento, fornecendo paradigmas de desenvolvimento comprovados. Design de software eficaz requer considerar as questões que não podem tornar-se visíveis até mais tarde na execução. Reutilizando padrões de projeto ajuda a prevenir problemas sutis que podem causar grandes problemas e melhora a legibilidade do código para programadores e arquitetos familiarizado com os padrões.

Esta classe é responsável por controlar todo e qualquer evento ocorrido. Em relação aos controles visuais a classe Activity não se responsabiliza por cria-las, na verdade dentro dela é chamada a classe View, que essa sim é responsável pela chamada pelo controle visual, objetos de um game, canvas e etc.

O Android trabalha com o conceito de pilhas, a forma que ele gerencia as Activity, ou seja, a tela que estiver na apresentação do celular, esta estará no topo da pilha. No momento em que se chama uma outra tela, esta nova irá para o topo e a que se encontrava anteriormente no topo fica em segundo lugar na pilha.

O Android trata TODAS as Activitys da mesma forma, seja ela desenvolvida por “terceiros” ou nativa.

Podemos considerar que esta classe é a mais poderosa da estrutura do Android. É impossível imaginar a não utilização dela. É através dela que a aplicação irá se comunicar, não somente através de janelas da própria aplicação, como também com as aplicações nativas do Android.

Os dois primeiros dias do evento (27 e 28 de julho) ocorrerá alguns cursos, dentre eles cursos sobre TDD, certificação para scrum master, certificação para product owner e sobre Lean Thinking. O restante dos dias serão para palestras, workshops e etc.

Neste grande evento teremos a oportunidade de ouvir o Jim Highsmith, consultor executivo para a ThoughtWorks, Vinícius Teles, um desenvolvedor e fundador da empresa ImproveIt e também o Joshua Kerievsky, um especialita na metodologia XP e Lean.