229 lines
12 KiB
Markdown
229 lines
12 KiB
Markdown
---
|
|
title: Creating a Project with Django
|
|
localeTitle: Criando um projeto com o Django
|
|
---
|
|
Agora que sabemos como criar ambientes virtuais e usar pip, podemos começar a construir nosso projeto. Neste artigo, vamos criar nosso primeiro projeto Django, escrever testes e iniciar nosso servidor de desenvolvimento.
|
|
|
|
## Criando o ambiente virtual
|
|
|
|
Primeiro, vamos criar um novo ambiente virtual para este projeto. (Se você ainda não o fez, desative o virtualenv anterior digitando `deactivate` no terminal). Para mais informações sobre ambientes virtuais e como usá-los, visite esta página .
|
|
|
|
Navegue até o diretório em que você deseja o projeto Django e digite o seguinte no terminal:
|
|
```
|
|
mkvirtualenv taskplanner --python=/usr/bin/python3
|
|
```
|
|
|
|
Você pode ter que mudar o caminho do Python se ele for diferente do que está acima.
|
|
|
|
Agora, o shell da linha de comando deve se parecer abaixo, indicando que você está em um ambiente virtual.
|
|
```
|
|
(taskplanner)<a href='https://sites.google.com/a/chromium.org/chromedriver/downloads' target='_blank' rel='nofollow'>munsterberg@Lenovo ~/workspace] $
|
|
```
|
|
|
|
Se não parecer assim, basta digitar:
|
|
```
|
|
workon taskplanner
|
|
```
|
|
|
|
Agora podemos instalar o Django:
|
|
```
|
|
pip install Django
|
|
```
|
|
|
|
## Crie o nosso projeto Django
|
|
|
|
Com o Django instalado, podemos criar nosso projeto:
|
|
```
|
|
django-admin.py startproject taskplanner
|
|
```
|
|
|
|
Em seguida, navegue até nosso novo projeto digitando:
|
|
```
|
|
cd taskplanner
|
|
```
|
|
|
|
Antes de fazermos qualquer coisa, vamos configurar este diretório como nosso diretório de trabalho usando virtualenvwrapper:
|
|
```
|
|
setvirtualenvproject
|
|
```
|
|
|
|
**Nota** : Para obter uma lista de comandos virtualenvwrapper, digite `virtualenvwrapper` no seu terminal.
|
|
|
|
Agora, quando estamos em nosso ambiente virtual, podemos digitar `cdproject` para navegar diretamente para nosso diretório de trabalho.
|
|
|
|
O diretório do seu projeto deve ser algo como isto:
|
|
```
|
|
taskplanner // our main working directory
|
|
|--- manage.py // similar to the django-admin script, you will see this used a
|
|
// lot throughout our project
|
|
|--- taskplanner
|
|
|--- __init__.py // this just tells python to treat this directory as a package
|
|
|--- settings.py // main configuration file for our project
|
|
|--- urls.py // we will use this to configure urls
|
|
|--- wsgi.py // this is used for deploying our project to a production server
|
|
```
|
|
|
|
## Teste funcional
|
|
|
|
O desenvolvimento orientado a testes é uma prática recomendada amplamente usada no desenvolvimento de software. Bascialmente, queremos escrever um teste primeiro que esteja fadado a falhar e, em seguida, escreva a menor quantidade possível de código para passar no teste. Com o Django, nosso objetivo é escrever tanto testes funcionais (também conhecidos como testes de integração, testes de ponta a ponta, etc.), quanto testes de unidade ao longo do desenvolvimento. Não se preocupe, testar não é tão difícil quanto parece!
|
|
|
|
Mas primeiro, precisamos criar um novo ambiente virtual dedicado ao teste. Abra uma nova aba no seu terminal, navegue até o diretório do projeto do seu planejador de tarefas e digite:
|
|
```
|
|
mkvirtualenv taskplanner_test --python=/usr/bin/python3
|
|
```
|
|
|
|
Agora você deve ter 2 guias abertas em seu terminal, uma no ambiente virtual (planejador de tarefas) e a outra no ambiente virtual (taskplanner\_test).
|
|
|
|
Se você digitar `pip freeze` em nosso novo ambiente de teste (taskplanner\_test), você notará que nada aparece. Isso porque ainda precisamos instalar qualquer coisa em nosso novo ambiente.
|
|
|
|
Então vamos em frente e instalar o Django primeiro em nosso ambiente de teste (taskplanner\_test):
|
|
```
|
|
pip install Django
|
|
```
|
|
|
|
Para criar nossos testes funcionais, vamos precisar de algumas coisas. Primeiro, precisamos ter o navegador Firefox instalado em nossa máquina. Se você não tem o Firefox, instale isso agora.
|
|
|
|
**Sidenote** : você pode usar o Chrome para testes de integração, mas é necessário fazer o download do driver [aqui](https://sites.google.com/a/chromium.org/chromedriver/downloads) e seguir [essa pergunta de estouro de pilha](http://stackoverflow.com/questions/13724778/how-to-run-selenium-webdriver-test-cases-in-chrome) . O Firefox teve um desempenho historicamente melhor que o chrome ao executar testes de integração, o que é uma consideração muito importante, já que, em comparação com os testes de unidade, os testes de integração são extremamente lentos.
|
|
|
|
Isso ocorre porque os testes de integração estão testando **todo o** sistema, em vez de 'unidades' (pequenos componentes). No mundo real, às vezes é melhor evitar testes de integração por causa do longo tempo de desenvolvimento para criá-los, tempo de execução lento, erros ambíguos e outras razões que você descobriria a tempo.
|
|
|
|
No entanto, eles ainda valem a pena quando desenvolvemos um aplicativo do mundo real e podem ser muito úteis em termos de confiabilidade, apesar das desvantagens do desempenho.
|
|
|
|
Em seguida, precisamos instalar um pacote chamado [Selenium](http://selenium.googlecode.com/svn/trunk/docs/api/py/index.html) . Este pacote nos fornecerá um WebDriver para que possamos controlar um navegador com nossos testes. O selênio é geralmente usado para automatizar seu navegador.
|
|
```
|
|
pip install selenium
|
|
```
|
|
|
|
Agora que temos isso instalado, precisaremos de um diretório para criar nossos testes:
|
|
```
|
|
mkdir functional_tests
|
|
```
|
|
|
|
No diretório do `taskplanner` , você deve ver o seguinte:
|
|
```
|
|
taskplanner
|
|
|-- functional_tests
|
|
|--- manage.py
|
|
|--- taskplanner
|
|
...
|
|
```
|
|
|
|
Agora precisamos criar alguns arquivos em nossa pasta `functional_tests` . Nós iremos criar um arquivo `__init__.py` (isto irá dizer ao python para tratar `functional_tests` como um pacote), e um arquivo `test_all_users.py` para conter nossos testes.
|
|
|
|
Vamos fazer isso agora:
|
|
```
|
|
touch functional_tests/__init__.py
|
|
touch functional_tests/test_all_users.py
|
|
```
|
|
|
|
**Sidenote** : `__init__.py` é quase sempre um arquivo vazio. Para mais informações sobre o que é usado, veja [esta resposta do stackoverflow.](http://stackoverflow.com/questions/448271/what-is-init-py-for)
|
|
|
|
Podemos finalmente começar a escrever nosso primeiro teste funcional! Testes funcionais são para testar partes da funcionalidade em nosso aplicativo da web. O TDD com Python descreve testes funcionais como "como o aplicativo funciona do ponto de vista do usuário".
|
|
|
|
Então vamos abrir o arquivo `test_all_users.py` em nosso editor de texto. Primeiro, queremos importar o webdriver do selenium, e para tornar isso muito mais fácil, o Django fornece algo conhecido como StaticLiveServerTestCase para testes ao vivo. Vamos importar os dois agora:
|
|
```
|
|
from selenium import webdriver
|
|
from django.contrib.staticfiles.testing import StaticLiveServerTestCase
|
|
```
|
|
|
|
Como estamos testando da perspectiva do usuário, vamos nomear esses testes como NewVisitorTest. Adicione o seguinte:
|
|
```
|
|
class NewVisitorTest(StaticLiveServerTestCase):
|
|
def setUp(self):
|
|
self.browser = webdriver.Firefox()
|
|
self.browser.implicitly_wait(2)
|
|
|
|
def tearDown(self):
|
|
self.browser.quit()
|
|
```
|
|
|
|
Primeiro, criamos uma classe StaticLiveServerTestCase denominada NewVisitorTest, isso conterá nossos testes que queremos executar para um novo visitante. Então, temos dois métodos chamados setUp e tearDown. O método setUp é inicializado quando executamos nossos testes. Então, para cada teste que executamos, abrimos o Firefox e esperamos 2 segundos para que a página seja carregada. O tearDown é executado após o término de cada teste. Esse método fecha o navegador para nós após cada teste.
|
|
|
|
Agora podemos escrever nosso primeiro teste e abrir e fechar o Firefox automaticamente para nós. Vamos escrever nosso teste agora abaixo do método tearDown.
|
|
```
|
|
def test_home_title(self):
|
|
self.browser.get('http://localhost:8000')
|
|
self.assertIn('Welcome to Django', self.browser.title)
|
|
```
|
|
|
|
Nosso primeiro teste, que emocionante! Vamos andar por isso. Todos os testes que queremos criar devem começar com "teste". Por exemplo, se eu quisesse criar um teste para o meu css, eu chamaria o método `test_h2_css` . Então, aqui, `test_home_title` o teste `test_home_title` . Isso é bastante auto-explicativo, o que é exatamente o que queremos para nossos testes. O método primeiro traz o Firefox para a url `http://localhost:8000` , e então verifica se 'Welcome to Django' está no título das tags head html.
|
|
|
|
Vamos executar este teste agora e ver o que acontece:
|
|
```
|
|
python manage.py test functional_tests
|
|
```
|
|
|
|
Primeiro, o que exatamente estamos digitando aqui? O script manage.py nos fornece algo chamado 'teste', usaremos isso para executar todos os nossos testes. Aqui estamos executando em nosso pacote `functional_tests` que criamos com o arquivo `__init__.py` .
|
|
|
|
Depois de executar isso, você deve ver algo como o seguinte no seu terminal:
|
|
```
|
|
F
|
|
======================================================================
|
|
FAIL: test_home_title (functional_tests.test_all_users.NewVisitorTest)
|
|
----------------------------------------------------------------------
|
|
Traceback (most recent call last):
|
|
File "/Users/username/url/to/project/taskplanner/functional_tests/test_all_users.py", line 15, in test_home_title
|
|
self.assertIn('Welcome to Django', self.browser.title)
|
|
AssertionError: 'Welcome to Django' not found in 'Problem loading page'
|
|
|
|
----------------------------------------------------------------------
|
|
Ran 1 test in 4.524s
|
|
|
|
FAILED (failures=1)
|
|
```
|
|
|
|
Então falhou, mas nos deu alguns conselhos úteis. Primeiro, o AssertionError. 'Bem-vindo ao Django' não encontrado em 'Página de carregamento de problemas'. Isso significa que o título de `http://localhost:8000` era 'Página de carregamento de problemas'. Se você navegar até o URL, verá que a página da Web não estava disponível.
|
|
|
|
Vamos tentar executar nosso servidor Django para fazer o teste passar. Volte para a guia do terminal que está no ambiente virtual do `taskplanner` de `taskplanner` e execute nosso servidor.
|
|
```
|
|
python manage.py runserver
|
|
```
|
|
|
|
Você deve ver algo como o seguinte:
|
|
```
|
|
Performing system checks...
|
|
|
|
System check identified no issues (0 silenced).
|
|
|
|
You have unapplied migrations; your app may not work properly until they are applied.
|
|
Run 'python manage.py migrate' to apply them.
|
|
|
|
March 06, 2016 - 20:53:38
|
|
Django version 1.9.4, using settings 'taskplanner.settings'
|
|
Starting development server at http://127.0.0.1:8000/
|
|
Quit the server with CONTROL-C.
|
|
```
|
|
|
|
Não se preocupe com a mensagem de migrações não aplicadas ainda.
|
|
|
|
Agora que temos um servidor em execução em `http://localhost:8000` , vamos executar nosso teste novamente.
|
|
|
|
Volte para a guia do outro terminal que está no ambiente virtual `taskplanner_test` e execute o seguinte uma vez mais:
|
|
```
|
|
python manage.py test functional_tests
|
|
```
|
|
|
|
Você deve ver o seguinte.
|
|
```
|
|
Creating test database for alias 'default'...
|
|
.
|
|
----------------------------------------------------------------------
|
|
Ran 1 test in 4.033s
|
|
|
|
OK
|
|
Destroying test database for alias 'default'...
|
|
```
|
|
|
|
## O que fizemos até agora
|
|
|
|
Nosso primeiro teste de passagem!
|
|
|
|
Nós cobrimos muito neste artigo. Criamos nosso primeiro projeto, configuramos ambientes virtuais para fins de desenvolvimento e teste, escrevemos nosso primeiro teste funcional e seguimos o processo de desenvolvimento orientado por teste, escrevendo um teste com falha e, em seguida, fazendo com que ele passasse.
|
|
|
|
## Usando modelos iniciais
|
|
|
|
Você pode economizar muito tempo iniciando o kickstart em seu projeto com um modelo inicial de django. Esses projetos usam práticas recomendadas que poupam dores de cabeça mais tarde quando o projeto cresce. Alguns dos projetos mais populares são
|
|
|
|
* [Cortador de biscoito](https://github.com/pydanny/cookiecutter-django)
|
|
* [Partida de Hackathon](https://github.com/DrkSephy/django-hackathon-starter)
|
|
* [Beira](https://github.com/arocks/edge) |