Testes: Uma prática necessária

Dando uma breve pausa nos posts sobre lógica, hoje falo sobre testes, uma prática de desenvolvimento muito importante na construção de um sistema.
Nos dias atuais implementar o teste de software no ciclo de vida do sistema é de extrema importância, porém ainda existem muitas barreiras, por conta de recursos humanos, disponibilidade de tempo, e até recursos financeiros reduzidos.
Agora pare e pense, para ser construído um navio, avião, carro. Será que cada peça não precisa ser passada por constantes testes?
Será que um avião é simplesmente montado e já está autorizado e apto para voar com dezenas ou centenas de pessoas dentro?
No mundo do desenvolvimento, é comum estudar o problema (fazendo levantamento dos requisitos), pensar na solução e em seguida implementá-la, e depois fazer vários testes manuais na procura de algum erro e corrigindo aos poucos. Só que esse processo, principalmente na fase de testes finais tende a levar muito tempo, gera-se uma grande quantidade de erros no sistema, e afeta a manutenibilidade. E é por isso e por outras problemáticas que é necessário ter uma ou mais fases de teste.
Existem vários tipos de testes como: Testes Unitários, Teste de carga, Testes de Performance e entre outros:

Teste Unitário - O teste unitário irá testar a menor parte do sistema, que seriam os métodos. Irá avaliar se tal método atende ao que ele diz o que faz e qual o seu retorno (independente de seus parâmetros).

(Teste manual simples para inserir um cliente) 

Nesse caso, após a execução do script seria necessário olhar no console se a lista retornada condiz com o que esperamos.

A principio resolvemos parte da problemática em não testar o método utilizando-se de métodos manuais, mas será que esse(s) teste(s) manterão a sua qualidade durante muito tempo? E se fosse repetido todos os dias? Com certeza, alguma regra iria mudar e com isso o teste manual perderia a sua confiabilidade. Para que isso não ocorra, no mundo Java, existe um framework de testes unitários que trabalha com testes automatizados.

JUnit 

JUnit é um framework de testes que fornece uma API para construir os testes unitários automatizados e ajuda na visualização dos resultados. É possível verificar se cada método, está sendo executado da forma esperada.

Abaixo tem o passo a passo de como utilizar o JUnit na IDE Eclipse e um exemplo de teste (happy path) com a ferramenta.

1 - Clique em File, New, Other, Pesquise Por JUnit Test Case e clique em Next. 

2- Digite o nome da classe de teste (Recomendado ser o nome da classe a qual você quer testar + a palavra 'Test'), após no campo Class under test, clique em Browser e pesquise o nome da classe, a qual você irá testar, após clique em Next.

 

3- Escolha os métodos que você quer testar e depois clique em Finish.

4- Nesse passo, a classe já foi criada e já implementei o teste, no caso como eu escolhi o método inserir(), então desenvolvi o cenário, ação e a validação (utilizando o método assertEquals() da classe Assert).

5- Ao executar a classe ClienteDAOTest, o Eclipse mostra a tela do JUnit, informando quantos testes foram executados, e se houve algum erro ou alguma falha:

Testes de Performance.

O teste de perfomance consiste em verificar o quanto a aplicação se mantém durante um determinado tempo. Falando em testes de performances, existem alguns como: carga, stress e etc.

Teste de Carga

O teste de carga, irá verificar o quanto a aplicação comporta, porém o número de usuários, ou transações é aumentado gradativamente.
 

Teste de Stress

O teste de Stress, irá verificar o quanto a aplicação comporta, porém com um número x de usuários, fazendo n transações ao mesmo tempo.
 
JMeter. 
Para realizar esses testes, temos uma aplicação open source desenvolvida em Java que mensura o nível de performance, trabalhando com protocolos HTTP e HTTPS, Webservices (SOAP e REST), JDBC e etc.
(http://jmeter.apache.org/)
Nas próximas publicações, irei mostrar como utilizar o JMeter para realizar esses testes. Fique ligado!

Como vimos,é importante adotar a prática de desenvolvimento junto com testes, para que tenhamos produtividade, e que o nosso trabalho tenha mais qualidade. Os próximos posts práticos utilizaremos a metodoogia TDD - Desenvolvimento Orientado a Testes. 

Siga-me nas redes sociais:
Twitter: @devhiranneri
Github:github.com/hiranneri
Linkedin: linkedin.com/in/hiranneri

Obrigado pela leitura e até a próxima :)

#3: Desafios de Lógica: Remover elementos repetidos

Olá novamente, neste post, darei prosseguimento na série de posts sobre lógica, e agora vamos complementar o exercício anterior:

- Precisamos ordernar os elementos de um array e remover os elementos repetidos.

Para ordernar os elementos iremos utilizar a mesma resolução do problema anterior utilizando algoritmo bolha para ordenação.

Após solicitar um número x de nomes para o usuário e orderná-los, iremos remover eventuais elementos repetidos neste array.
A principio é necessário a criação:

String nomesSemRepeticao[] = new String[nomes.length];
int quantidadeDeElementosUnicos = 0;
 
Logo abaixo do algoritmo eu explico como foi pensado. 

for( int i = 0 ; i < original.length ; i++ ) {
                boolean existe = false;
                for( int j = 0 ; j < quantidadeDeElementosUnicos ; j++ ) {
                   
                    if( elementosSemRepeticao[ j ] .equals( original[ i ] )) {
                        existe = true;
                        break;
                    }
                }
               
                if( !existe ) {
                    elementosSemRepeticao[ quantidadeDeElementosUnicos++ ] = original[ i ];
                }
               
            }
         for(String nomes:elementosSemRepeticao){
             System.out.println(nomes);
         }

Explicação:
 
Foi criado um novo array que conterá somente elementos não repetidos, com o tamanho igual ao o array que armazenou os nomes digitados.

Foi criada a variável quantidadeDeElementosUnicos para termos ciência em qual índice o valor está sendo adicionado no array de elementos unicos.
 
A seguir foi criado uma estrutura de repetição para pecorrermos o array nomes[]. Na linha abaixo foi criada uma variável booleana para sabermos se foi encontrado algum valor repetido.

O segundo for só poderá ser executado na segunda iteração, pois j (j=0) não será menor do que quantidadeDeElementosUnicos(=0), sendo assim, cairá no segundo if, e caso o valor inverso da variável existe for igual a true, o primeiro elemento é adicionado no array.

Na segunda iteração, o j valerá 0 e quantidadeDeElementosUnicos será iterado valendo 1, assim os próximos elementos serão avaliados e se o valor do array de quantidadeDeElementosUnicos[] for igual ao valor do array nome[], então a variável existe será true, e o break da linha abaixo irá parar a condição, e a execução irá para o segundo if. (Nestas iterações, quando é encontrado um valor igual, o elemento não é adicionado, porque como a variável existe é igual a true, o valor inverso de true não executará o if que adiciona o elemento).

Após todas as iterações ocorrerem e somente os elementos forem adicionados, no final tem um for each que apresenta os valores em ordem alfabética e sem repetição.

Assim concluímos mais um desafio!

O código para resolução deste problema foi localizado no:
 https://pt.stackoverflow.com/questions/14339/eliminar-valores-repetidos-array-java

Siga-me nas redes sociais:
Twitter: @devhiranneri
Github:github.com/hiranneri
Linkedin: linkedin.com/in/hiranneri

Obrigado pela leitura e até a próxima :)