Concrete Logo
Hamburger button

Como desenvolver app iOS com TDD, cobertura e Integração Contínua – Parte 1

  • Blog
  • 5 de Fevereiro de 2014
Share

Esta é a primeira parte de uma série de quatro posts sobre iOS, TDD e integração contínua que vamos compartilhar aqui no Blog nas próximas semanas. Neste primeiro post, vamos falar sobre como criar um projeto iOS usando cocoapods e Specta (Framework TDD/BDD, que torna a escrita dos testes muito mais legível e expressiva), além de como adicionar cobertura de testes no mesmo com LCOV.

Na segunda parte, mostraremos como testar suas viewControllers e mockar serviços usando OCMock juntamente com Specta e Expecta. Os últimos 2 posts serão dedicados à integração contínua e vão mostrar passo a passo como configurar o servidor de CI tanto com Bots (Servidor de CI da apple) quanto com Jenkins.

Pra quem quiser clonar o Projeto no github: https://github.com/thiagolioy/dribbbleIos.git

Passos para rodar o projeto após clonar :

1 – cd dribbbleIos/DribbbleIos

2 – pod install

3 –  Siga os passos 7.1 e 7.2 mais abaixo.

Antes de começar o projeto em qualquer parte (de código propriamente dita), o ideal é que eventuais problemas de configuração sejam resolvidos para que os mesmos não voltem a surgir mais à frente na vida útil do projeto ou sirvam como desculpa para abandonar o uso de testes, por exemplo. Acredite: ter essa disciplina e foco no início do projeto evita muita dor de cabeça no futuro.

Dito isso, como primeiras tarefas antes de começar a parte de código, procurei escrever um dummy test usando o Specta (nosso framework de TDD/BDD) e fazer a cobertura de testes funcionar para esse primeiro teste. Feito isso, podemos ficar tranquilos e começar a construir nosso projeto e escrever nossos testes sabendo que partimos de um lugar seguro.

Vamos ao passo-a-passo:

Pré requisitos:

– Cocoapods (https://guides.cocoapods.org/using/getting-started.html)

– Homebrew (https://brew.sh/)

– Instalar LCOV pelo homebrew (brew install lcov)

1 – Criar o projeto no Github ou repo da sua escolha. O github já tem a opção de incluir um .gitignore para projetos de iOS. Escolha essa opção, adicione um README/licença se desejar e clone o projeto na sua máquina.

2 – Crie um projeto no xcode dentro do diretório clonado.

3 – Adicione um Podfile ao projeto.

Passo 3

4 – Rode o pod install no mesmo diretório que você salvou o Podfile para instalar as dependências e configurar o projeto. Depois que isso for feito, comece a acessar o projeto por meio do .xcworkspace que contém o projeto principal/tests + o projeto do pods (Bibliotecas do projeto configuradas pelo Podfile).

Passo 4

5- Crie seu primeiro dummy test com Specta. Por default, o projeto já vai ser configurado com um test inicial, {NomeDoProjeto}Test.m dentro da pasta de tests do projeto. Substitua a implementação dele por uma com Specta.

Passo 5

*Às vezes é preciso reabrir o Xcode após esse primeiro teste, mas um bom indicador é: se o highlight de código pegar no novo conteúdo do arquivo de teste, está tudo certo.

6 – Rode os testes (cmd + U é o atalho). Se não funcionar, reveja os passos até aqui.

7 – Agora está na hora de adicionar cobertura. Para isso, eu quero citar duas fontes interessantes. A prim
eira é esse github: https://github.com/jonreid/XcodeCoverage, um projeto que conta com scripts que facilitam na hora de gerar a cobertura. O Readme desse projeto é bem descritivo e explica como configurar o build settings do projeto para adicionar as flags necessárias para que o compilador gere os arquivos para a cobertura.

O segundo ponto é que para o xcode 5 iOS7 era preciso criar um hack para fazer o flush após o término dos testes, caso contrário os arquivos .gcda não seriam gerados e não conseguiríamos criar a cobertura com o LCOV.

https://stackoverflow.com/questions/19136767/generate-gcda-files-with-xcode5-ios7-simulator-and-xctest

O link do Stackoverflow é bem descritivo e conta com muitos passos. Por sorte, estamos usando o Specta e eu fiz uma hackzinha para gerar esses arquivos sem precisar seguir os passos do link do Stackoverflow. Na prática, você não vai bater tanto a cabeça como eu bati =). Mesmo assim, tem alguns passos para fechar a cobertura:

7.1 – Adicione as 4 linhas para configurar o flush do gcov no willTerminate do AppDelegate. Só vai ser chamado em modo de Debug, modo no qual os testes rodam.

Passo 7.1

7.2 – cmd + shift + f e busque por stopObserving. Clique na referência dentro da classe XCTestLog+Specta.m, edite o método XCTestLog_stopObserving e adicione as 2 linhas sublinhadas.

Passo 7.2

8 – Se tudo foi feito como mencionado, incluindo as configurações expressas no github do XcodeCoverage, após rodar os testes entre no diretório XcodeCoverage e rode ./getcov. Esse comando vai gerar a cobertura e abrir o Safari com o relatório.

Tem um passo extra: eu editei os scripts do XcodeCoverage, no caso o envcov.sh e o getcov, para refletir as minhas configurações (usando o LCOV instalado pelo homebrew). Qualquer dúvida, verifique os arquivos do repositório disponibilizado.

Caso tudo tenha dado certo, você deve estar agora com o projeto configurado com Cocopods e Specta e gerando cobertura com os scripts do XcodeCoverage usando o LCOV.

Passo 8

No próximo post, escreveremos a aplicação (um cliente simplificado para consumir a API do Dribbble) e seus testes. Alguma dúvida até aqui? Deixe nos comentários!

Update: Continue aprendendo sobre integração contínua na parte 2 e na parte 3 desta série.