Sådan oprettes et projekt med Django

Nu hvor vi ved, hvordan man opretter virtuelle miljøer og bruger pip, kan vi begynde at bygge vores projekt. I denne artikel opretter vi vores første Django-projekt, skriver tests og starter vores udviklingsserver.

Oprettelse af det virtuelle miljø

Lad os først oprette et nyt virtuelt miljø til dette projekt. (Hvis du ikke allerede har deaktiveret den forrige virtualenv ved at skrive deactivateterminalen). For mere info om virtuelle miljøer og hvordan man bruger dem, skal du besøge denne side.

Naviger til det bibliotek, hvor du vil have Django-projektet, og skriv følgende i terminalen:

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

Du bliver muligvis nødt til at ændre din Python-sti, hvis den ser anderledes ud end den ovenfor.

Kommandolinjeskallen skal nu se ud nedenfor, hvilket indikerer, at du befinder dig i et virtuelt miljø.

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

Hvis det ikke ser sådan ud, skal du bare skrive:

workon taskplanner

Vi kan nu installere Django:

pip install Django

Opret vores Django-projekt

Med Django installeret kan vi oprette vores projekt:

django-admin.py startproject taskplanner

Gå derefter ind i vores nye projekt ved at skrive:

cd taskplanner

Før vi gør noget, lad os indstille denne mappe som vores arbejdsmappe ved hjælp af virtualenvwrapper:

setvirtualenvproject

Sidenote : For en liste over virtualenvwrapper-kommandoer, skrivvirtualenvwrapperind i din terminal.

Nu, når vi er i vores virtuelle miljø, kan vi skrive for cdprojectat navigere direkte til vores arbejdskatalog.

Din projektmappe skal se sådan ud:

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

Funktionel testning

Testdrevet udvikling er en meget anvendt bedste praksis til udvikling af software. Grundlæggende vil vi først skrive en test, der sandsynligvis mislykkes, og derefter skrive den mindst mulige mængde kode for at bestå testen. Med Django er vores mål at skrive både funktionelle tests (også kendt som; integrationstest, end-to-end-test osv.) Og enhedstest under hele udviklingen. Ikke sved det, test er ikke så svært, som det ser ud til!

Men først skal vi oprette et nyt virtuelt miljø dedikeret til test. Åbn en ny fane i din terminal, naviger til din taskplanner-projektmappe, og skriv:

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

Nu skal du have 2 faner åbne i din terminal, den ene i det (taskplanner) virtuelle miljø og den anden i det (taskplanner_test) virtuelle miljø.

Hvis du indtaster pip freezevores nye testmiljø (taskplanner_test), vil du bemærke, at der ikke vises noget. Dette skyldes, at vi endnu ikke har installeret noget i vores nye miljø.

Så lad os gå videre og installere Django først i vores testmiljø (taskplanner_test):

pip install Django

For at skabe vores funktionelle tests har vi brug for et par ting. Først skal vi have Firefox-webbrowseren installeret på vores maskine. Hvis du ikke har Firefox, skal du installere det nu.

Sidenote : Du kan bruge Chrome til integrationstest, men du skal downloade driveren her og følge dette stackoverløbsspørgsmål. Firefox har haft historisk bedre ydeevne end krom, når man kører integrationstest, hvilket er en meget vigtig overvejelse, da integrationstest sammenlignet med enhedstest er ekstremt langsomme.

Dette skyldes, at integrationstest tester hele systemet i stedet for 'enheder' (små komponenter). I den virkelige verden er det undertiden bedst at undgå integrationstests på grund af den lange udviklingstid til at skabe dem, langsom kørselstid, tvetydige fejl og andre grunde, du ville opdage i tide.

De er dog stadig værd at overveje, når vi udvikler en app fra den virkelige verden, og kan være meget nyttige med hensyn til pålidelighed på trods af præstationsnedsættelserne.

Dernæst skal vi installere en pakke kaldet Selenium. Denne pakke giver os en WebDriver, så vi kan styre en browser med vores tests. Selen bruges normalt til at automatisere din browser.

pip install selenium

Nu hvor vi har det installeret, har vi brug for en mappe til at oprette vores tests:

mkdir functional_tests

I taskplannerbiblioteket skal du nu se følgende:

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

Vi har nu brug for at oprette et par filer i vores functional_testsmappe. Vi opretter en __init__.pyfil (dette vil fortælle python at behandle functional_testssom en pakke) og en test_all_users.pyfil, der indeholder vores tests.

Lad os gøre det nu:

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

Sidenote :__init__.pyer næsten altid en tom fil. For mere information om hvad det bruges til, se dette stackoverflow-svar.

Vi kan endelig begynde at skrive vores første funktionelle test! Funktionelle tests er til test af klumper af funktionalitet i vores webapplikation. TDD med Python beskriver funktionstest som “hvordan applikationen fungerer fra brugerens synspunkt”.

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

Du kan spare dig selv meget tid ved at starte dit projekt med en django-startskabelon. Disse projekter bruger bedste praksis, der sparer dig hovedpine senere, når dit projekt vokser. Nogle af de mere populære projekter er

  • Kageskærer
  • Hackathon starter
  • Edge