Curso TDD e Testes Automatizados com Java

Sobre o curso

Desenvolva aplicações Java com produtividade sustentável e segurança com uso de testes automatizados com jUnit. Evolua seu código com qualidade e boas práticas através do uso de testes de unidade, mocks, TDD e refatoração contínua. Valide sua camada de persistência, SQL's e acesso ao banco de dados com testes de integração. Faça testes de ponta a ponta na sua aplicação Web com Selenium/Webdriver. Analise a cobertura de código do seu projeto com a ferramenta EclEmma do Eclipse. Automatize seu projeto com as ferramentas Apache Ant e Maven.

20 horas

R$ 949.00

Garanta a qualidade interna do seu software de forma sustentável e contínua.

Conteúdo do curso
* Grade, carga horária e valores sujeitos a mudanças

  1. Entendendo a importância dos testes automatizados

    1. Por que devemos testar nosso software?
    2. Por que não testamos?
    3. Testes manuais e testes automatizados
    4. Leitura recomendada
    5. Tirando dúvidas
  2. Definição do projeto

    1. Conhecendo o projeto e negócio
    2. Tecnologias escolhidas
    3. Entendendo nosso modelo
    4. Conhecendo o código fonte do projeto
    5. Exercícios: Importando o projeto no Eclipse
  3. Testando a primeira funcionalidade

    1. Nova funcionalidade
    2. Implementando a nova funcionalidade
    3. Exercícios: implementando a funcionalidade e suas regras
    4. Testando nosso código
    5. Problemas com testes manuais
    6. Testando com método main()
    7. Exercícios: testando a código via método main() e sysout
    8. Discussão: problemas dessa abordagem
  4. Testes de Unidade

    1. O que é um teste de unidade
    2. Estrutura básica de um teste de unidade
    3. Parte 1: Cenário
    4. Parte 2: Ação
    5. Parte 3: Validação
    6. Conhecendo a ferramenta jUnit
    7. Importando e configurando o jUnit no projeto
    8. Exercícios: adicionando jUnit ao classpath
    9. Escrevendo nosso primeiro teste de unidade
    10. Exercícios: escrevendo e rodando o teste de unidade
    11. Testando outros cenários
    12. Exercícios: testando outros fluxos de negócio
  5. Qualidade dos testes

    1. Importância da qualidade dos testes
    2. Import Estático
    3. Exercícios: usando imports estáticos
    4. Nomenclatura
    5. Nomes de métodos mais legíveis
    6. Exercícios: melhorando os nomes dos métodos
    7. Repetição de código
    8. Extraindo rotinas que se repetem com @Before
    9. Exercícios: extraindo código que se repete
    10. Limpando a sujeira de um teste com @After
    11. Exercícios: limpando o que o teste sujou
    12. Testando fluxos de exceção e erro
    13. Exercícios: esperando uma exceção nos testes
    14. Evitando construção de código complexo com o padrão Test Data Builder
    15. Exercícios: criando nosso Test Data Builder
    16. Para saber mais: testes isolados e independentes
  6. Objetos dublês (Mock Objects)

    1. Limitações
    2. Por que isolar nosso código sob teste de sistemas externos?
    3. Simulando comportamentos através de mocks
    4. Exercícios: criando nosso objeto dublê
    5. Conhecendo o framework Mockito
    6. Exercícios: configurando o Mockito no projeto
    7. Passando um objeto mock como dependência
    8. Configurando um ou mais comportamentos para nosso mock
    9. Exercícios: configurando comportamentos no mock
    10. Configurando mock para lançar uma exceção
    11. Exercícios: configurando mock para lançar exceções
    12. Testando comportamentos através de mocks
    13. Garantindo que os métodos do mock foram invocados
    14. Garantindo a quantidade de vezes que os métodos do mock foram invocados
    15. Exercícios: testando os comportamentos dos mocks
    16. Discussão: Usar mocks é fácil?
  7. TDD - Test Driven Development

    1. Entendendo as vantagens
    2. Pensando no problema antes de escrever o código de produção
    3. Escrevendo testes antes do código de produção
    4. Escrevendo o código de produção mínimo para o teste passar
    5. Refatorando código de produção com uma melhor solução
    6. Refatorando código de produção sem medo
    7. Entendendo o ciclo do TDD e baby-steps
    8. Exercícios: praticando TDD
    9. Vantagens do TDD: Maior Coesão, menor Acoplamento e melhor Encapsulamento
    10. Discussão: Devo usar TDD a todo momento?
  1. Correção de bugs

    1. Novo bug no sistema
    2. Identificando e simulando o bug
    3. O que fazer primeiro: corrigir ou escrever o teste?
    4. Escrevendo o teste para encontrar o bug no código
    5. Exercícios: encontrando o bug com testes
    6. Próximo passo: corrigindo o bug e vendo a barra verde
    7. Exercícios: corrigindo o bug e rodando os testes novamente
  2. Cobertura de código e testes

    1. Quanto do nosso código foi coberto por testes?
    2. Ferramentas de cobertura de código
    3. EclEmma: cobertura de código no Eclipse
    4. Rodando a cobertura de código em um método, numa classe e em todo o projeto
    5. Exercícios: Instalando EclEmma no Eclipse e analisando a cobertura de código do projeto
    6. Discussão: Ter 100% de cobertura de código é o ideal?
  3. Testes de Integração

    1. Os diferentes tipos de testes: unidade, integração e aceitação
    2. Entendendo as vantagens e desvantagens
    3. Código que acessa o banco de dados
    4. Quando não utilizar mocks?
    5. Exercícios: mockando a consulta ao banco de dados
    6. Faz sentido mockar acesso ao banco?
    7. Implementando testes de integração para camada de persistência (DAO’s)
    8. Exercícios: testando métodos do DAO
    9. Para saber mais: Limpando e populando o banco de dados antes de cada teste
    10. Separando os testes de integração dos testes de unidade
    11. Exercícios: separando e organizando os testes de unidade e integração
    12. Discussão: algumas percepções sobre testes de integração
  4. Refatoração contínua do código

    1. Medo de alterar código de outro programador
    2. Lidando com código legado ou mal escrito
    3. Cobre com testes depois refatora
    4. Exercícios: cobrindo com testes e refatorando
    5. Problema: consulta lenta
    6. Refatorando consulta e rodando testes
    7. Exercícios: refatorando consulta
    8. Discussão: aplicando TDD para resolver bugs
  5. Testes de Aceitação

    1. Introdução
    2. O que devemos testar?
    3. Os critérios de aceitação do cliente
    4. Usando o browser para testar
    5. Seu primeiro teste com Selenium WebDriver
    6. Exercícios: primeiro teste com Selenium WebDriver
    7. Preenchendo formulários
    8. Exercícios: preenchendo e submetendo formulários via Selenium
    9. Testando telas com AJAX
    10. Exercícios opcionais: lidando com requisições AJAX e JavaScript
    11. Boas práticas com o padrão Page Objects
    12. Discussão: algumas percepções sobre testes de aceitação
    13. Para saber mais: Estratégias de como organizar os testes de aceitação
  6. Apêndice - Automatizando o projeto e os testes

    1. Entendendo a importância de tarefas automatizadas
    2. Conhecendo a ferramenta Ant
    3. Configurando e utilizando o Ant via Eclipse
    4. Exercícios: configurando o Ant no Eclipse
    5. Exercícios opcionais: rodando o Ant via linha de comando
    6. Escrevendo o script de build com Ant
    7. Fase 1: Compilar o código Java
    8. Fase 2: Rodar a bateria de testes
    9. Fase 3: Gerar nosso .war
    10. Exercícios: escrevendo o script de build do Ant
    11. Para saber mais: conhecendo o Maven
    12. Para saber mais: Indo além com integração contínua
  7. Apêndice - Discussão em sala

    1. Pirâmide de Testes
    2. Testes de Unidade vs Testes de Aceitação
    3. Classe com muitos testes pode ser um mau sinal
    4. Testes com muitos assertivas é ruim?
    5. O excesso de mocks nos testes significa algo
    6. Trabalhando a granularidade dos testes e objetos
    7. TDD e princípios SOLID
    8. Ferramentas para limpar e popular o banco de dados
    9. Para saber mais: testes de integração com Spring e Java EE

Inscrições

Veja as próximas datas do curso e matricule-se!

*Pagamento à vista ou outras formas de pagamento entrar em contato.

Turma Data Período Local
#01 11/Abr a 15/Abr (seg a sexta) Noite (18h às 22h) TriadWorks Vagas encerradas!
#02 25/Jun a 09/Jul (sábado) Sábado (09h às 17h) TriadWorks Vagas encerradas!
#03 16/Julho a 30/Julho (sábado) Diurno (09h às 17h) TriadWorks Vagas encerradas!
#04 03/Dez a 17/Dez (sábado) Diurno (09h às 17h) TriadWorks