Pergunta

Ok, talvez eu estou faltando alguma coisa, mas eu realmente não vejo o ponto de selênio. Qual é o ponto de abrir o navegador usando o código, clicando em botões usando o código, e verificação de texto usando o código? Eu li o site e vejo como, em teoria, seria bom para automaticamente teste de unidade suas aplicações web, mas no final não apenas levar muito mais tempo para escrever todo esse código em vez de apenas clicando em torno e verificar visualmente as coisas funcionam ?

Eu não entendo ...

Foi útil?

Solução

Ele permite que você escrever testes funcionais em sua "unidade" testando-quadro (a questão é a nomeação da tarde).

Quando você está testando o aplicativo através do navegador que você está normalmente testar o sistema totalmente integrado. Considere que você já tem para testar as alterações antes de cometer eles (testes de fumo), você não quiser testá-lo manualmente mais e mais.

Algo muito bom, é que você pode automatizar seus testes de fumo, e QA pode aumentar os. Bastante eficaz, uma vez que reduz a duplicação de esforços e recebe toda a equipe mais perto.

Ps como qualquer prática que está a utilizar pela primeira vez ele tem uma curva de aprendizado, por isso geralmente leva mais tempo nas primeiras vezes. Sugiro também que você olhar para o padrão do objeto página , ajuda em manter os testes limpo.

Update 1: Observe que os testes também será executado javascript nas páginas, o que ajuda testando páginas altamente dinâmicas. Observe também que você pode executá-lo com diferentes navegadores, para que possa verificar questões cross-browser (pelo menos no lado funcional, como você ainda precisa verificar o visual).

Observe também que como a quantidade de páginas cobertos por testes acumula-se, você pode criar testes com ciclos completos de interações rapidamente. Usando o padrão de objeto de página eles se parecem com:

   LastPage aPage = somePage
      .SomeAction()
      .AnotherActionWithParams("somevalue")
      //... other actions
      .AnotherOneThatKeepsYouOnthePage(); 
  // add some asserts using methods that give you info
  // on LastPage (or that check the info is there).
  // you can of course break the statements to add additional 
  // asserts on the multi-steps story.

É importante compreender que você vai gradual sobre isso. Se é um sistema já construído, você adicionar testes para características / mudanças que você está trabalhando. Adicionando mais e mais cobertura ao longo do caminho. Indo manual em vez, geralmente esconde o que você perdeu para teste, então se você fez uma alteração que afeta cada única página e você irá verificar um subconjunto (como o tempo não permite), você sabe quais os que você realmente testados e QA pode trabalhar a partir de lá (espero, adicionando ainda mais testes).

Outras dicas

Esta é uma coisa comum que é dito sobre o teste de unidade em geral. "Eu preciso escrever duas vezes mais código para testar?" Os mesmos princípios se aplicam aqui. A recompensa é a capacidade de alterar o código e saber que você não está quebrando nada.

Porque você pode repetir o MESMO teste de uma e outra vez.

Se a sua aplicação é ainda 50+ páginas e você precisa fazer frequente constrói e testá-lo contra um número X de principais navegadores faz muito sentido.

Imagine que você tem 50 páginas, todos com 10 ligações cada, e alguns com formas multi-estágio que exigem que você vá através das formas, colocando em cerca de 100 diferentes conjuntos de informações para verificar se eles funcionam corretamente com todos os números de cartão de crédito , todos os endereços de todos os países, etc.

Isso é virtualmente impossível testar manualmente. Torna-se tão propenso a erro humano que você não pode garantir o teste foi feito para a direita, não importa o que o teste provou sobre a coisa que está sendo testado.

Além disso, se você seguir um modelo de desenvolvimento moderno, com muitos desenvolvedores de todo o trabalho no mesmo local em um desconectado, forma distribuída (alguns trabalham no site de seu laptop, enquanto em um avião, por exemplo), então os testadores humanos não vai mesmo ser capaz de acessá-lo, muito menos ter a paciência para re-teste de cada vez que um único desenvolvedor tenta algo novo.

Em qualquer tamanho decente do site, os testes têm de ser automatizado.

O ponto é o mesmo que para qualquer tipo de testes automatizados: escrever o código pode levar mais tempo do que "apenas clicando em torno e visualmente verificar as coisas funcionam", talvez 10 ou mesmo 50 vezes mais

.

Mas qualquer aplicação não trivial terá de ser testado muito mais do que 50 vezes, eventualmente, e os testes manuais são uma tarefa irritante que provavelmente será omitido ou feito shoddily sob pressão, o que resulta em erros restantes não descoberto até pouco bfore (ou depois) prazos importantes, que resulta em estressante toda a noite de codificação sessões ou perda ainda outright monetária devido a penalidades contratuais.

O selênio (juntamente com ferramentas semelhantes, como Watir) permite executar testes contra a interface do usuário do seu aplicativo Web de forma que os computadores são bons em: milhares de vezes durante a noite, ou em poucos segundos depois de cada checkin fonte. (Note-se que há uma abundância de outros UI testar peças que os seres humanos são muito melhores em, como perceber que algo estranho não diretamente relacionado com o teste está errado.)

Existem outras maneiras de envolver toda a pilha de seu aplicativo por olhar para o HTML gerado, em vez de lançar um navegador para torná-lo, tais como Webrat e Mecanizar . A maioria destes não tem uma maneira de interagir com UIs JavaScript-pesados; O selênio tem você um pouco coberto aqui.

O selênio irá gravar e re-executar todos o clique manual e digitação você faz para testar a sua aplicação web. Mais e mais.

Mais de estudos em tempo de me mostraram-me que eu tendem a fazer menos testes e começar a pular alguns, ou esquecê-las.

O selênio em vez disso, tomar cada teste, executá-lo, se ele não voltar o que você espera dele, pode informá-lo.

Há um custo inicial de tempo para gravar todos esses testes. Eu gostaria de recomendar como testes de unidade -. se você não tiver já, começar a usá-lo com o mais complexo, sensível, ou partes mais atualizados do seu código

E se você salvar esses testes como classes JUnit você pode executar novamente-los em seu lazer, como parte de sua compilação automatizada, ou em teste de carga de um pobre homem usando JMeter.

Em um trabalho passado, usado para teste de unidade nosso web-app. Se o web-app muda seu olhar os testes não precisam ser re-escrita. ensaios de tipo Record-e-repetição que todos precisam ser re-feito.

Por que você precisa de selênio? Porque testers são seres humanos. Eles vão para casa todos os dias, pode nem sempre fins de semana de trabalho, tomar sickies, tomar feriados, ir de férias de vez em quando, se cansar fazendo tarefas repetitivas e nem sempre pode contar com eles sendo em torno de quando você precisa deles.

Eu não estou dizendo que você deve se livrar de testadores, mas uma interface automatizada testando testers do sistema complementos de ferramentas.

O ponto é a capacidade de automatizar o que era antes de um teste consumir manual e tempo. Sim, é preciso tempo para escrever os testes, mas uma vez por escrito, que pode ser executado tantas vezes quanto os desejos da equipe. Cada vez que eles são executados, eles estão verificando que o comportamento da aplicação web é consistente. O selênio não é um produto perfeito, mas é muito bom para automatizar interação com o usuário realista com um navegador.

Se você não gosta da abordagem selênio, você pode tentar HtmlUnit , acho que é mais útil e fácil de integrar em testes de unidade existentes.

Para aplicações com interfaces web ricas (como muitos projetos GWT) Selenium / Eólica / WebDriver / etc é o caminho para criar testes de aceitação. Em caso de GWT / GXT, o código de interface do utilizador final, é em JavaScript criando assim testes de aceitação usando processos normais de teste junit é, basicamente, fora de questão. Com Selênio pode criar cenários de teste correspondentes ações do usuário reais e resultados esperados.

Com base na minha experiência com selênio pode revelar erros na lógica da aplicação e interface de usuário (no caso de seus casos de teste são bem escritos). Lidar com front-ends AJAX exige algum esforço extra, mas ainda é viável.

Eu usá-lo para testar formulários de várias páginas como isso leva a carga fora de digitar a mesma coisa uma e outra vez. E ter a capacidade de verificar se determinados elementos estão presentes é grande. Novamente, usando a forma como exemplo o teste de selênio final poderia verificar se algo como dizer "obrigado Sr. Rogers para encomendar ..." aparece no final do processo de encomenda.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top