Cómo crear un proyecto con Django

Ahora que sabemos cómo crear entornos virtuales y usar pip, podemos comenzar a construir nuestro proyecto. En este artículo, crearemos nuestro primer proyecto Django, escribiremos pruebas e iniciaremos nuestro servidor de desarrollo.

Creando el entorno virtual

Primero, creemos un nuevo entorno virtual para este proyecto. (Si aún no lo ha hecho, desactive el virtualenv anterior escribiendo deactivateen la terminal). Para obtener más información sobre los entornos virtuales y cómo utilizarlos, visite esta página.

Navegue hasta el directorio donde desea el proyecto Django y escriba lo siguiente en la terminal:

mkvirtualenv taskplanner --python=/usr/bin/python3

Es posible que deba cambiar su ruta de Python si se ve diferente a la anterior.

El shell de la línea de comandos debería verse ahora como a continuación, lo que indica que se encuentra en un entorno virtual.

(taskplanner)[email protected] ~/workspace] $

Si no se ve así, simplemente escriba:

workon taskplanner

Ahora podemos instalar Django:

pip install Django

Crea nuestro proyecto Django

Con Django instalado podemos crear nuestro proyecto:

django-admin.py startproject taskplanner

A continuación, navegue hasta nuestro nuevo proyecto escribiendo:

cd taskplanner

Antes de hacer nada, establezcamos este directorio como nuestro directorio de trabajo usando virtualenvwrapper:

setvirtualenvproject

Nota al margen : Para obtener una lista de los comandos virtualenvwrapper, escribavirtualenvwrapperen su terminal.

Ahora, cuando estamos en nuestro entorno virtual, podemos escribir cdprojectpara navegar directamente a nuestro directorio de trabajo.

El directorio de tu proyecto debería verse así:

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

Pruebas funcionales

El desarrollo basado en pruebas es una práctica recomendada ampliamente utilizada en el desarrollo de software. Básicamente, queremos escribir primero una prueba que esté destinada a fallar, y luego escribir la menor cantidad de código posible para pasar esa prueba. Con Django, nuestro objetivo es escribir tanto pruebas funcionales (también conocidas como; pruebas de integración, pruebas de extremo a extremo, etc.) como pruebas unitarias durante todo el desarrollo. ¡No se preocupe, las pruebas no son tan difíciles como parece!

Pero primero, necesitamos crear un nuevo entorno virtual dedicado a las pruebas. Abra una nueva pestaña en su terminal, navegue hasta el directorio del proyecto de su planificador de tareas y escriba:

mkvirtualenv taskplanner_test --python=/usr/bin/python3

Ahora debería tener 2 pestañas abiertas en su terminal, una en el entorno virtual (planificador de tareas) y la otra en el entorno virtual (planificador de tareas).

Si escribe pip freezeen nuestro nuevo entorno de prueba (taskplanner_test), notará que no aparece nada. Esto se debe a que todavía tenemos que instalar nada en nuestro nuevo entorno.

Así que vayamos a instalar Django primero en nuestro entorno de prueba (taskplanner_test):

pip install Django

Para crear nuestras pruebas funcionales vamos a necesitar algunas cosas. Primero, necesitamos tener el navegador web Firefox instalado en nuestra máquina. Si no tiene Firefox, instálelo ahora.

Nota al margen : puede usar Chrome para las pruebas de integración, pero debe descargar el controlador aquí y seguir esta pregunta de desbordamiento de pila. Firefox ha tenido históricamente un mejor rendimiento que Chrome al ejecutar pruebas de integración, lo cual es una consideración muy importante ya que en comparación con las pruebas unitarias, las pruebas de integración son extremadamente lentas.

Esto se debe a que las pruebas de integración prueban todo el sistema, en lugar de "unidades" (componentes pequeños). En el mundo real, a veces es mejor evitar las pruebas de integración debido al largo tiempo de desarrollo para crearlas, el tiempo de ejecución lento, los errores ambiguos y otras razones que descubriría a tiempo.

Sin embargo, aún merecen nuestra consideración al desarrollar una aplicación del mundo real y pueden ser muy útiles en términos de confiabilidad a pesar de las desventajas de rendimiento.

A continuación, necesitamos instalar un paquete llamado Selenium. Este paquete nos proporcionará un WebDriver para que podamos controlar un navegador con nuestras pruebas. El selenio se usa generalmente para automatizar su navegador.

pip install selenium

Ahora que lo tenemos instalado, necesitaremos un directorio para crear nuestras pruebas:

mkdir functional_tests

En el taskplannerdirectorio ahora debería ver lo siguiente:

taskplanner |-- functional_tests |--- manage.py |--- taskplanner ...

Ahora necesitamos crear algunos archivos en nuestra functional_testscarpeta. Crearemos un __init__.pyarchivo (esto le indicará a Python que lo trate functional_testscomo un paquete) y un test_all_users.pyarchivo para contener nuestras pruebas.

Hagámoslo ahora:

touch functional_tests/__init__.py touch functional_tests/test_all_users.py

Nota al margen :__init__.pycasi siempre es un archivo vacío. Para obtener más información sobre para qué se utiliza, consulte esta respuesta de stackoverflow.

¡Finalmente podemos empezar a escribir nuestra primera prueba funcional! Las pruebas funcionales son para probar partes de la funcionalidad en nuestra aplicación web. TDD con Python describe las pruebas funcionales como "cómo funciona la aplicación desde el punto de vista del usuario".

So let’s open the test_all_users.py file in our text editor. First, we want to import selenium’s webdriver, and to make this a lot easier, Django provides something known as StaticLiveServerTestCase for live testing. Let’s import both of those now:

from selenium import webdriver from django.contrib.staticfiles.testing import StaticLiveServerTestCase

Since we are testing from the users perspective, let’s name these tests NewVisitorTest. Add the following:

class NewVisitorTest(StaticLiveServerTestCase): def setUp(self): self.browser = webdriver.Firefox() self.browser.implicitly_wait(2) def tearDown(self): self.browser.quit()

First, we create a StaticLiveServerTestCase class named NewVisitorTest, this will contain our tests that we want to run for a new visitor. Then, we have two methods named setUp and tearDown. The setUp method is initialized when we run our tests. So, for each test we run, we open Firefox and wait 2 seconds for the page to load. tearDown runs after each test is finished, this method closes the browser for us after each test.

Now we can write our first test, and have Firefox open and close automatically for us. Let’s write our test now below the tearDown method.

 def test_home_title(self): self.browser.get('//localhost:8000') self.assertIn('Welcome to Django', self.browser.title)

Our first test, how exciting! Let’s walk through it. Every test we want to create must start with ‘test’. For example, if I wanted to create a test for my css, I would call the method test_h2_css. So here, we named the test test_home_title. That’s pretty self-explanatory, which is exactly what we want for our tests. The method first brings Firefox to the url //localhost:8000, and then it checks if ‘Welcome to Django’ is in the html head tags title.

Let’s run this test now and see what happens:

python manage.py test functional_tests

First, what exactly are we typing here? The manage.py script provides us with something called ‘test’, we will use this to run all of our tests. Here we are running it on our functional_tests package that we created with the __init__.py file.

After running this you should see something like the following in your 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)

So it failed, but it gave us some handy advice. First, the AssertionError. ‘Welcome to Django’ not found in ‘Problem loading page’. So that means the title of //localhost:8000 was ‘Problem loading page’. If you navigate to the url, you will see that the web page was not available.

Let’s try running our Django server to get the test to pass. Switch back to the terminal tab that is in the taskplanner virtual environment and run our server.

python manage.py runserver

You should see something like the following:

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 //127.0.0.1:8000/ Quit the server with CONTROL-C.

Don’t worry about the unapplied migrations message yet.

Now that we have a server running on //localhost:8000, lets run our test again.

Go back to the other terminal tab that is in the taskplanner_test virtual environment and run the following once more:

python manage.py test functional_tests

You should see the following.

Creating test database for alias 'default'... . ---------------------------------------------------------------------- Ran 1 test in 4.033s OK Destroying test database for alias 'default'...

What We’ve Done So Far

Our first passing test!

We’ve covered a lot in this article. We created our first project, set up virtual environments for both development and testing purposes, wrote our first functional test, and followed the Test-driven development process by writing a failing test, and then making it making it pass.

Using starter templates

You can save yourself a lot of time by kickstarting your project with a django starter template. These projects use best practices that will save you headaches later when your project grows. Some of the more popular projects are

  • Cookiecutter
  • Hackathon starter
  • Edge