Kā izveidot projektu ar Django

Tagad, kad mēs zinām, kā izveidot virtuālo vidi un izmantot pip, mēs varam sākt veidot savu projektu. Šajā rakstā mēs izveidosim savu pirmo Django projektu, rakstīsim testus un palaidīsim mūsu attīstības serveri.

Virtuālās vides veidošana

Vispirms izveidosim jaunu virtuālo vidi šim projektam. (Ja vēl neesat to izdarījis, deaktivizējiet iepriekšējo virtuālo programmu, ierakstot deactivateterminālu). Lai iegūtu papildinformāciju par virtuālajām vidēm un to izmantošanu, apmeklējiet šo lapu.

Pārejiet uz direktoriju, kurā vēlaties Django projektu, un terminālā ierakstiet:

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

Jums var būt jāmaina Python ceļš, ja tas izskatās savādāk nekā iepriekš.

Komandrindas apvalkam tagad vajadzētu izskatīties šādi, norādot, ka atrodaties virtuālā vidē.

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

Ja tas neizskatās tā, vienkārši ierakstiet:

workon taskplanner

Tagad mēs varam instalēt Django:

pip install Django

Izveidojiet mūsu Django projektu

Ar instalēto Django mēs varam izveidot savu projektu:

django-admin.py startproject taskplanner

Pēc tam pārejiet uz mūsu jauno projektu, ierakstot:

cd taskplanner

Pirms kaut ko darīsim, iestatīsim šo direktoriju kā mūsu darba direktoriju, izmantojot virtualenvwrapper:

setvirtualenvproject

Sidenote : Lai iegūtu virtualenvwrapper komandu sarakstu, ierakstietvirtualenvwrapperterminālā.

Tagad, atrodoties virtuālajā vidē, mēs varam rakstīt, cdprojectlai virzītos tieši uz mūsu darba direktoriju.

Jūsu projekta direktorijai vajadzētu izskatīties apmēram šādi:

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

Funkcionālā pārbaude

Testu vadīta izstrāde ir plaši izmantota programmatūras izstrādes labākā prakse. Pēc būtības mēs vispirms gribam uzrakstīt pārbaudi, kurai noteikti neizdodas, un pēc tam uzrakstīt vismazāko koda daudzumu, kas ir nepieciešams šī testa nokārtošanai. Izmantojot Django, mūsu mērķis ir rakstīt gan funkcionālos testus (pazīstamus arī kā; integrācijas testi, end-to-end testi utt.), Gan vienības testus visā izstrādes laikā. Nesviediet to, testēšana nav tik grūta, kā šķiet!

Bet vispirms mums ir jāizveido jauna testēšanai veltīta virtuālā vide. Atveriet jaunu cilni savā terminālā, dodieties uz uzdevumu plānotāja projekta direktoriju un ierakstiet:

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

Tagad jūsu terminālī vajadzētu būt atvērtām 2 cilnēm, viena virtuālajā vidē (taskplanner) un otra virtuālajā vidē (taskplanner_test).

Ja jūs rakstīt pip freezemūsu jaunajā testēšanas vidē (taskplanner_test), jūs ievērosiet nekas neparādās. Tas ir tāpēc, ka mums vēl nekas nav jāinstalē jaunajā vidē.

Tāpēc turpināsim un vispirms instalējiet Django mūsu testēšanas vidē (taskplanner_test):

pip install Django

Lai izveidotu funkcionālos testus, mums būs nepieciešamas dažas lietas. Pirmkārt, mūsu mašīnā ir jābūt instalētai Firefox tīmekļa pārlūkprogrammai. Ja jums nav Firefox, instalējiet to tūlīt.

Sidenote : Integrācijas testēšanai varat izmantot pārlūku Chrome, taču šeit ir jāielādē draiveris un jāievēro šis kaudzes pārpildes jautājums. Veicot integrācijas testus, pārlūkprogrammai Firefox ir bijusi vēsturiski labāka veiktspēja nekā hromam, kas ir ļoti svarīgs apsvērums, jo, salīdzinot ar vienības testiem, integrācijas testi ir ļoti lēni.

Tas notiek tāpēc, ka integrācijas testi pārbauda visu sistēmu, nevis “vienības” (mazos komponentus). Reālajā pasaulē dažreiz vislabāk ir izvairīties no integrācijas testiem, jo ​​to izveidei ir nepieciešams ilgs izstrādes laiks, lēns darbības laiks, neskaidras kļūdas un citi iemesli, kurus jūs savlaicīgi atklātu.

Tomēr tie joprojām ir mūsu uzmanības vērti, izstrādājot reālās pasaules lietotni, un uzticamības ziņā tie var būt ļoti noderīgi, neskatoties uz veiktspējas negatīvajām pusēm.

Tālāk mums jāinstalē pakete ar nosaukumu Selenium. Šī pakete mums nodrošinās WebDriver, lai mēs ar testiem varētu kontrolēt pārlūku. Selēns parasti tiek izmantots, lai automatizētu jūsu pārlūkprogrammu.

pip install selenium

Tagad, kad tas ir instalēts, testu izveidošanai mums būs nepieciešams direktorijs:

mkdir functional_tests

Šajā taskplannerkatalogā jums tagad vajadzētu redzēt šādi:

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

Tagad mums ir jāizveido daži faili mūsu functional_testsmapē. Mēs izveidosim __init__.pyfailu (tas liks pitonam izturēties functional_testskā pret paketi) un test_all_users.pyfailu, kurā būs mūsu testi.

Darīsim to tagad:

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

Sidenote :__init__.pygandrīz vienmēr ir tukšs fails. Lai iegūtu papildinformāciju par to, kādam nolūkam to izmantojat, skatiet šo pārsūtīšanas plūsmas atbildi.

Beidzot varam sākt rakstīt savu pirmo funkcionālo testu! Funkcionālie testi ir paredzēti, lai pārbaudītu funkcionalitātes fragmentus mūsu tīmekļa lietojumprogrammā. TDD ar Python apraksta funkcionālos testus kā “kā lietojumprogramma darbojas no lietotāja viedokļa”.

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

Jūs varat ietaupīt daudz laika, uzsākot projektu ar django startera veidni. Šajos projektos tiek izmantota paraugprakse, kas ietaupīs jūsu galvassāpes vēlāk, kad jūsu projekts pieaugs. Daži no populārākajiem projektiem ir

  • Cepumu griezējs
  • Hakatona starteris
  • Mala