getting started with fitnesse collaboration tool
Agora o mundo está mudando para o Agile. O feedback inicial e contínuo é fundamental para qualquer equipe scrum. Como o mundo está mudando, a mentalidade dos testadores também precisa ser mudada.
Em vez de “encontrar bugs, quebrar software, medir requisitos”, os testadores agora estão pensando em “entregar a qualidade, logo na primeira vez, teste sem a IU ou teste antes mesmo que a IU esteja disponível”.
Os testadores agora também precisam responder às mudanças e, portanto, é importante sair da técnica de teste da caixa preta e não esperar até que a IU seja desenvolvida; em vez disso, comece a testar as entregas intermediárias também.
O que você aprenderá:
qual o melhor spyware para telefones celulares
- Mas por que?
- O que é FitNesse?
- Por que devo usar o FitNesse?
- Então, o que posso criar?
- Baixando e configurando o FitNesse:
- Exemplo de FitNesse - O material para testar:
- Escrevendo seu teste no FitNesse:
- Alguns insights sobre estilos de fixação / mesa:
- Recomendação:
- Conclusão
- Leitura recomendada
Mas por que?
“AGORA ESTA É UMA PERSPECTIVA MUITO ÁGIL”.
Sempre que construímos software, as camadas mais baixas de testes são mantidas no nível da unidade / componente. Os testes de unidade são realizados pela equipe de desenvolvimento. Esses testes de unidade são muito orientados para a tecnologia e, em sua maioria, escritos na mesma linguagem em que o sistema em teste está escrito.
Esses testes de unidade são escritos com “ Unidade X ”Ferramenta de teste. Dizemos no mundo dos testes que se nosso teste de unidade for sólido como uma rocha , os defeitos são identificados muito mais cedo e o teste acima da camada de teste de unidade torna-se fácil em um ambiente estável. E quando falamos em Agile, dizemos que se uma equipe domina a arte de TDD (Test Driven Development), os testes de nível de unidade fornecem o feedback mais rápido.
A camada acima da camada de unidade / componente é a camada de testes de aceitação que é realizada para o negócio. Esses são testes funcionais têm mais cobertura do que os testes de unidade e são mais frequentemente executados por não desenvolvedores. Esses testes testam a camada por trás da camada de apresentação ou APIs. Essas APIs ou métodos, quando testados, fornecem um feedback rápido e, no momento em que a GUI é desenvolvida, a maioria das funcionalidades são testadas.
FitNesse é um exemplo dessa camada de testes de aceitação automatizada.
O que é FitNesse?
FitNesse é “Um wiki autônomo totalmente integrado e estrutura de teste de aceitação”. É o servidor web wiki de código aberto. Wiki- porque permite criar suas próprias páginas web nas quais as tabelas de teste são criadas. Essas tabelas de teste nada mais são do que dados de teste .
Sua intenção é oferecer suporte ao estilo ágil de aceitação da caixa preta e teste de regressão. Também é uma ferramenta de colaboração porque os testadores colaboram com os desenvolvedores para preparar o conjunto de testes.
Por que devo usar o FitNesse?
A equipe de teste Agile pode usar o FitNesse para preparar trajes de teste que testarão os métodos no código. FitNesse é análogo a Junit de uma forma que também testa os métodos, mas é diferente do Junit porque os testes estão na forma de tabelas simples que podem ser usadas por desenvolvedores e não desenvolvedores.
Benefícios:
- Feedback antecipado, executando os testes de aceitação automatizados com a freqüência necessária.
- Os resultados dos testes são determinísticos porque são destacados em vermelho ou verde.
- Os dados de teste podem ser projetados para atender às necessidades de qualidade.
- Os testes são escritos em uma linguagem simples e fácil de entender, pois são escritos em forma de tabela.
- Essas tabelas são definidas em termos de entradas e saídas esperadas.
- Ver tudo FitNesse apresenta aqui.
Então, o que posso criar?
No FitNesse, você pode criar testes e suítes. Os termos são praticamente os mesmos usados no mundo dos testes. Os testes são um script único e se adequam à coleção / grupo de testes. Quando você cria um traje e o executa, a vantagem é que todos os testes desse traje são executados. Portanto, você precisa de um planejamento adequado para organizar seus testes em um terno.
Baixando e configurando o FitNesse:
=> Para baixar o FitNesse, Clique aqui
(Observação: Clique em qualquer imagem para visualização ampliada)
Baixe a versão mais recente de fitnesse-standalone.jar e salve-o em sua unidade local.
Abra um prompt de comando e execute o arquivo jar. Para facilitar, criei um arquivo em lote:
Uma vez que o arquivo jar é executado, FitNesse é iniciado conforme mostrado abaixo: (clique na imagem para ampliá-la)
Para abrir o FitNesse, abra seu navegador e digite: http: // localhost: . Nesse caso, o número da porta é 2222.
A página recebida é mostrada abaixo: (clique na imagem para ampliá-la)
Então, aqui, se você pode ver a lista suspensa de testes, podemos criar uma “página de suíte”, bem como uma “página de teste”. Quando você cria uma suíte, todos os scripts de teste dentro dessa suíte são executados.
Para fins de explicação, estou usando um exemplo de página de teste.
Exemplo de FitNesse - O material para testar:
No momento, estamos testando um programa simples de calculadora mostrado abaixo.
Aqui está o código em java, que possui 4 métodos:
- Adição ()
- menos ()
- multiplique ()
- divide ()
(Por favor, veja que FitNesse funciona com qualquer linguagem de sua escolha. Para explicação, eu usei java)
Este código no mundo FitNesse é denominado “Fixture”.
As luminárias nada mais são do que o código de amostra - ou um link entre FitNesse e o aplicativo em teste. Então, sempre que quisermos testar um método, temos que escrever um fixture e este fixture irá invocar e testar o método.
Portanto, o código 'Fixture' para o nosso exemplo é o seguinte:
publicclass Calculator { privateint first,second; publicvoid setFirst(int first) { this.first=first; } publicvoid setSecond(int second) { this.second=second; } publicint addition() { return (first+second); } publicint minus() { return (first-second); } publicint multiply() { return (first*second); } publicfloatdivide() { return (first/second); } }
O código no eclipse é mostrado como: (clique na imagem para ampliá-la)
Precisaríamos do arquivo de classe, portanto, certifique-se de compilá-lo.
Escrevendo seu teste no FitNesse:
Passo 1) Vamos voltar ao navegador onde temos a página inicial do FitNesse.
Na página inicial, clique em “Página de teste”, digite o nome do teste e clique no botão “Salvar”. No nosso caso, é “Calculadora”
Passo 2) No seu URL, acrescente o nome do seu teste com um ponto “.” Operador.
Gostar: http: // localhost: 2222 / FrontPage.Calculator
Etapa 3) Clique no botão Editar e insira as linhas mostradas abaixo
Aqui estão as linhas inseridas:
! defina TEST_SYSTEM {slim}
! caminho F: Eclipse TestFitness bin
! | Calculadora |
| primeira | segunda | adição? | menos? | multiplicar? | dividir? |
| 4 | 2 | 6 | 2 | 8 | 2.0 |
| 10 | 5 | 15 | 5 | 50 | 2,0 |
| 10 | 10 | 20 | 0 | 100 | 1,0 |
Vamos entender as linhas uma por uma.
para) A primeira linha diz FitNesse para usar o sistema de teste SLIM.
pl sql perguntas da entrevista com respostas
( MAGRO - Significa Método de Invocação de Lista Simples. Ao dizer sistema de teste SLIM, todo o processamento da tabela é feito pela FitNesse. SLIM tem SLIM Runner e SLIM Executer. SLIM Runner divide as páginas de teste em instruções simples e essas instruções são passadas para SLIM Executer que direciona o código do aparelho para chamar o sistema em testes)
b) A segunda linha define a localização do arquivo de classe. Neste caso, o código java é compilado e o arquivo de classe é mantido no local “caminho F: Eclipse TestFitness bin'
c) A terceira linha indica o nome da Classe. No nosso caso é “Calculadora'
d) Agora vem a quarta linha:
As duas primeiras colunas| primeiro | segundo |são os parâmetros ou entradas para o método java.
As próximas 4 colunas, seguidas de “?”adição? | menos? | multiplicar? | dividir? | são os métodos da classe java. Esses métodos retornarão um valor que será comparado aos valores esperados.
é) As linhas:
| 4 | 2 | 6 | 2 | 8 | 2.0 |
| 10 | 5 | 15 | 5 | 50 | 2,0 |
| 10 | 10 | 20 | 0 | 100 | 1,0 |
São os casos de teste ou devo dizer dados de teste para o nosso método.
A primeira linha:
| primeira | segunda | adição? | menos? | multiplicar? | dividir? |
| 4 | 2 | 6 | 2 | 8 | 2.0 |
Receberá 4 como o primeiro parâmetro e 2 como o segundo parâmetro e passará esses dois valores no método de adição da classe java. O método será executado e retornará um valor. Este valor retornado será comparado com o valor esperado escrito sob 'adição?' qual é| 6 |
Da mesma forma, o FitNesse passará os 2 primeiros parâmetros no sinal de menos? Método da classe java e retorna um valor. Este valor será comparado com o valor esperado contra | 2 |
Da mesma forma, multiplicar? e dividir? funcionará tomando os valores do primeiro e do segundo parâmetro e retorna o valor que é comparado com| 8 | 2.0 |respectivamente
Da mesma forma, as 2 linhas abaixo (ou devo dizer os casos de teste) são executados.
| 10 | 5 | 15 | 5 | 50 | 2,0 |
| 10 | 10 | 20 | 0 | 100 | 1,0 |
Passo 4) Depois de editar seus testes, clique no botão Salvar e sua página ficará assim:
Etapa 5) Para executar os testes, clique no botão Testar e obteremos o resultado da seguinte forma: (clique na imagem para ampliá-la)
Para a primeira linha (que é nosso primeiro caso de teste), a cor verde destaca que os valores, retornados do método adição (), menos (), multiplicação () e divisão () estão combinando com o que é esperado, ou seja, 6, 2 , 8 e 2,0, respectivamente. Da mesma forma, para a segunda linha (que é o segundo caso de teste) todos os valores retornados dos métodos são correspondentes.
Etapa # 6) Agora, para demonstrar, deixe-me alterar alguns dos valores esperados para alguns outros valores (os valores estão incorretos, mas fiz isso propositalmente para explicação)
A partir de agora, tenho:
- Alterado o valor esperado de adição () para o primeiro caso de teste para 7
- Alterou o valor esperado para menos () para o segundo caso de teste
- Alterado o valor esperado para divide () para o terceiro caso de teste.
Etapa # 7) Execute o teste clicando no botão “Teste”. Os testes acima devem falhar. (clique na imagem para ampliá-la)
A cor vermelha destaca que esses testes falharam.
Alguns insights sobre estilos de fixação / mesa:
Vimos que no FitNesse os testes são executados executando linhas em uma tabela. Portanto, para executar diferentes tipos de testes (ou, devo dizer, para testar diferentes tipos de métodos), precisaríamos usar diferentes tipos de tabelas. Usamos os estilos de fixação / mesa abaixo com mais freqüência:
- Fixação da coluna - é mais amplamente usado (e é usado no exemplo acima). Aqui, as linhas de dados representam diferentes conjuntos de entrada e sua saída esperada.
- Acessórios de linha - É usado para testar consultas que retornam algum conjunto de valores.
- Jogos de ação - É usado para executar testes para uma sequência de eventos. Esses eventos podem ser como clicar em um botão, verificando valores
Recomendação:
Tentei demonstrar os conceitos para que possamos começar a explorar mais no FitNesse. A mentalidade do testador também precisa ser alterada e ampliada. Precisamos parar de nos restringir a olhar dentro do código. Eu sinto; em última análise, estamos testando o código, então por que não tentamos ver o código e testá-lo ali mesmo?
Comece a aprimorar suas habilidades de programação e enfatize mais a construção da lógica e, em vez disso, aprenda a sintaxe. Quando você estiver bem versado nos conceitos de programação e tiver prática em implementá-los, explorar o FitNesse se tornará mais fácil.
Conclusão
O teste ágil vem em 4 sabores:
- Teste de unidade automatizado - usando Junit
- Teste de verificação de aceitação automatizado - usando FitNesse
- Testes automatizados de IU / regressão - usando Selenium ou QTP
- Teste manual
Devemos tentar empurrar o máximo de nossos testes na unidade e na camada de aceitação . Até agora, tentamos manter a maior parte dos nossos testes para a camada de IU usando ferramentas como QTP e Selenium, mas a desvantagem aqui é que essas funcionalidades não poderiam ser testadas a menos que a IU seja desenvolvida. No momento em que você encontra um defeito, os desenvolvedores já passaram para o desenvolvimento de algum outro recurso.
Por outro lado, se pudermos testar as APIs logo depois de terem sido escritas, os desenvolvedores poderão corrigi-las instantaneamente. Isso também resultaria em menos esforço ao testar a GUI. Como todas as funcionalidades são testadas, testar a GUI se torna fácil.
Com o Agile, a mentalidade dos testadores também precisa de uma mudança e eles precisam sair de seu conjunto de rotina de testes e agora você deve olhar o código e tentar identificar defeitos, mesmo que a IU não esteja disponível.
Sobre o autor: Este é um artigo convidado do membro da equipe STH Shilpa C. Roy. Ela trabalha na área de teste de software há mais de 9 anos em áreas como publicidade na Internet, banco de investimento e telecomunicações.
Deixe-nos saber suas dúvidas nos comentários abaixo.
Leitura recomendada
- Os desenvolvedores não são bons testadores. O que você diz?
- Ferramenta gratuita útil de captura de tela e anotador para os testadores - revisão do qSnap
- As 10 ferramentas de revisão de código mais populares para desenvolvedores e testadores
- Revisão do WebLOAD - Introdução à ferramenta de teste de carga do WebLOAD
- As 15 principais ferramentas de teste de SOA para testadores
- Como manter a motivação viva em testadores de software?
- Análise da ferramenta de gerenciamento de teste TestLodge
- Habilidade suave para testadores: como melhorar a habilidade de comunicação