Tutorial ini mulai dimana Tutorial 4 ditinggalkan. Kami telah membangun aplikasi jejak pendapat jaringan, dan kami akan sekarang membuat otomatis percobaan untuknya.
\n\nPercobaan adalah rutin yang memeriksa tindakan dari kode anda.
\nPercobaan beroperasi di tingkatan berbeda. Beberapa percobaan mungkin berlaku ke rincian kecil (apakah cara model khas mengembalikan nilai sesuai diharapkan?) selama lainnya menguji operasi keseluruhan dari perangkat keras (apakah urutan dari masukan pengguna di situs menghasilkan hasil yang diinginkan?). Itu tidak berbeda dari beragam percobaan anda lakukan sebelumnya di Tutorial 2, menggunakan shell untuk menguji kebiasaan cara, atau menjalankan aplikasi dan memasukkan data untuk diperiksa bagaimana kebiasaannya.
Apa perbedaan di percobaan otomatis dimana percobaan bekerja selesai untuk anda oleh sistem. Anda membuat kumpulan percobaan sekali, dan lalu ketika anda membuat perubahan ke aplikasi anda, anda dapat memeriksa kode anda masih bekerja seperti anda inginkan aslinya, tanpa harus melakukan percobaan manual memakan waktu.
\nJadi mengapa membuat percobaan, dan jenapa sekarang?
\nAnda mungkin merasa bahwa anda sangat cukup hanya belajar Python/Django, dan tidak mempunyai hal lain untuk belajar dan melakukan nampak luar biasa dan mungkin tidak perlu. Setelah semua, aplikasi jejak pendapat bekerja sangat gembira sekarang; melalui masalah dari pembuatan percobaan otomatis tidak akan membuatnya bekerja lebih baik. Jika membuat aplikasi jejak pendapat adalah hal terakhir dari pemrograman Django anda pernah lakukan, lalu benar, anda tidak butuh membuat percobaan otomatis. Tetapi, jika itu bukan kasusnya, sekarang adalah waktu yang tepat untuk belajar.
\nSampai titik tertentu, 'memeriksa itu kelihatannya bekerja' akan menjadi percobaan memuaskan. Di lebih aplikasi menakjubkan, anda mungkin mempunyai lusinan interaksi rumit antara komponen.
\nKesempatan dalam tiap komponen tersebut dapat memiliki konsekuensi tidak diharapkan pada perilaku aplikasi. Memeriksa bahwa itu 'terlihat masih bekerja' dapat berarti berjalan melalui kegunaan kode anda dengan dua puluh ragam perbedaan dari percobaan data anda untuk memastikan ada belum memrusak sesuatu - bukan penggunaan bagus dari waktu anda.
\nItu terutama benar ketika percobaan otomatis dapat melakukan ini untuk anda dalam hitungan detik. Jika sesuatu berjalan salah, percobaan akan juga membantu mencirikan kode yang menyebabkan kebiasaan tidak diharapkan.
\nTerkadang dia kelihatan bertugas untuk menyobek air mata anda jauh dari produktif anda, bekerja pemrograman kreatif untuk menghadapi bisnis tidak menarik dan tidak menggairahkan dari percobaan penulisan terutama ketika anda mengetahui kode anda bekerja dengan benar.
\nBagaimanapun, tugas dari menulis percobaan adalah banyak lebih mengisi daripada menghabiskan berjam-jam mencoba aplikasi anda secara manual atau mencoba mencirikan penyebab dari masalah baru yang diperkenalkan.
\nAdalah sebuah kesalahan berpikir percobaan hanya aspek negatif dari pengembangan.
\nTanpa percobaan, tujuan atau kebiasaan dimaksud dari aplikasi mungkin agak buram. Bahkan ketika itu kode anda sendiri, anda akan terkadang menemukan diri anda mangaduk-aduknya dan mencoba menemukan apa sebenarnya yang dia lakukan.
\nPercobaan merubah itu; mereka menyalakan kode anda dari dalam, dan ketika sesuatu menjadi salah, mereka fokus menyalakan bagian yang berjalan salah - bahkan jika anda belum menyadarinya telah berjalan salah.
\nAnda mungkin telah membuat potongan perangkat keras hebat, tetapi anda akan menemukan bahwa pengembang lain akan menolat melihatnya karena itu kurang dicoba; tanpa dicoba, mereka tidak akan mempercayainya. Jacob Kaplan-Moss, satu dari pengembang asli Django, katakan "Kode tanpa percobaan adalah rusak berdasarkan rancangan."
\nBahwa pengembang lain ingin melihat percobaan di perangkat lunak anda sebelum mereka mengambilnya secara sungguh-sungguh adalah alasan lain untuk anda untuk memulai menulis percobaan.
\nTitik sebelumnya ditulis dari sudut pandang dari pengembang tunggal merawat sebuah aplikasi. Aplikasi rumit akan dirawat oleh tim. Jaminan percobaan dimana rekan tidak sengaja merusak kode anda (dan bahwa anda tidak merusak kode mereka tanpa diketahui). Jika anda ingin membuat hidup seperti pemrogram Django, anda harus menjadi bagus pada penulisan percobaan!
\nTerdapat banyak cara untuk mendekatkan penulisan percobaan
\nBeberapa pemrogram mengikuti disiplin dipanggil "test-driven development"; mereka sebenarnya menulis percobaan mereka sebelum mereka menulis kode mereka. Ini mungkin terlihat kontra-intuitif, tetapi kenyataannya itu mirip pada apa kebanyakan orang akan sering lakukan: mereka menggambarkan masalah, kemudian membuat beberapa kode untuk menyelesaikannya. Pengembangan didorong-percobaan memformalkan masalah dalam kasus percobaan Python.
\nLebih sering, pendatang baru untuk mencoba akan membuat beberapa kode dan kemudan memutuskan bahwa itu harus mempunyai beberapa percobaan. Mungkin itu akan lebih baik untuk menulis beberapa percobaan lebih awal, tetapi itu tidak pernah terlampat untuk mulai.
\nTerkadang adalah sangat sulit mencari tahu dimana untuk mulai dengan menulis percobaan. Jika anda telah menulis beberapa ribu baris Phyton, memilih sesuatu untuk dicoba mungkin tidak mudah. Di kasus seperti itu, adalah bermanfaat untuk menulis percobaan pertama anda lain kali anda membuat perubahan, salah satu anda menambahkan fitur atau memperbaiki kesalahan.
\nJadi mari kita melakukannya segera.
\nUntungnya, terdapat kesalahan sedikit di aplikasi polls untuk kami perbaiki segera: cara Question.was_published_recently() mengembalikan True jika Question telah diterbitkan dalam hari terakhir (yang benar) tetapi juga jika bidang pub_date Question di masa depan (yang tentu tidak).
Tegaskan kesalahan dengan menggunakan shell untuk memeriksa metode pada sebuah pertanyaan dimana tanggal berbohong di masa datang:
Linux / macOS
$ python manage.py shell\nWindows
...\\> py manage.py shell\n>>> import datetime\n>>> from django.utils import timezone\n>>> from polls.models import Question\n>>> # create a Question instance with pub_date 30 days in the future\n>>> future_question = Question(pub_date=timezone.now() + datetime.timedelta(days=30))\n>>> # was it published recently?\n>>> future_question.was_published_recently()\nTrue\nSejak hal-hal di masa depan tidak 'baru terjadi', hal ini jelaslah salah.
\nApa yang kita telah lakukan di shell untuk mencoba masalah adalah sebenarnya kami dapat lakukan di percobaan otomatis, jadi mari kita rubah itu menjadi percobaan otomatis.
Tempat biasa untuk percobaan aplikasi adalah di berkas aplikasi tests.py; sistem percobaan akan otomatis menemukan percobaan di berkas apapun yang namanya dimulai dengan test.
Taruh berikut di berkas tests.py di aplikasi polls :
import datetime\n\nfrom django.test import TestCase\nfrom django.utils import timezone\n\nfrom .models import Question\n\n\nclass QuestionModelTests(TestCase):\n\n def test_was_published_recently_with_future_question(self):\n """\n was_published_recently() returns False for questions whose pub_date\n is in the future.\n """\n time = timezone.now() + datetime.timedelta(days=30)\n future_question = Question(pub_date=time)\n self.assertIs(future_question.was_published_recently(), False)\nDisini kami telah membuat sebuah subkelas django.test.TestCase dengan sebuah metode yang membuat sebuah contoh Question dengan pub_date di masa depan. Kami kemudian memeriksa keluaran dari was_published_recently() - yang mungkin menjadi False.
Pada terminal, kita dapat menjalankan percobaan kita:
\nLinux / macOS
$ python manage.py test polls\nWindows
...\\> py manage.py test polls\ndan anda akan lihat sesuatu seperti:
\nCreating test database for alias 'default'...\nSystem check identified no issues (0 silenced).\nF\n======================================================================\nFAIL: test_was_published_recently_with_future_question (polls.tests.QuestionModelTests)\n----------------------------------------------------------------------\nTraceback (most recent call last):\n File "/path/to/mysite/polls/tests.py", line 16, in test_was_published_recently_with_future_question\n self.assertIs(future_question.was_published_recently(), False)\nAssertionError: True is not False\n\n----------------------------------------------------------------------\nRan 1 test in 0.001s\n\nFAILED (failures=1)\nDestroying test database for alias 'default'...\nApa yang terjadi adalah ini:
\nmanage.py test polls untuk melihat percobaan pada aplikasi polls
itu menemukan subkelas dari kelas django.test.TestCase
itu membuat basisdata khusus untuk tujuan percobaan
Itu mencari cara percobaan - satu yang namanya dimulai dengan test
di test_was_published_recently_with_future_question dia membuat sebuah instance Question yang bidang pub_date adalah 30 hari di masa depan
... dan menggunakan cara assertIs(), itu menemukan bahwa was_published_recently() mengembalikan True, meskipun kami menginginkannya mengembalikan False.
Percobaan menginformasikan kami yang mana percobaan gagal dan bahkan baris di mana kegagalan muncul.
\nKami sudah mengetahui bahwa masalahnya adalah: Question.was_published_recently() harus mengembalikan False jika pub_date nya berada di masa depan. Merubah cara di models.py, sehingga dia hanya mengembalikan True jika tanggal juga berada di masa lampau:
def was_published_recently(self):\n now = timezone.now()\n return now - datetime.timedelta(days=1) <= self.pub_date <= now\ndan jalankan percobaan kembali:
\nCreating test database for alias 'default'...\nSystem check identified no issues (0 silenced).\n.\n----------------------------------------------------------------------\nRan 1 test in 0.001s\n\nOK\nDestroying test database for alias 'default'...\nSetelah mengenali sebuah bug, kami menulis tes untuk menemukannya dan memperbaiki bug yang ada di dalam kode sehingga tes yang kami buat dapat berjalan lancar.
\nBanyak hal lain mungkin akan berjalan salah dengan aplikasi kami dimasa akan datang, tetapi kami yakin bahwa kami secara tidak sengaja memperkenalkan kembali kesalahan ini, karena menjalankan percobaan akan memperingati kami segera. Kami dapat membertimbangkan posi kecil ini dari aplikasi dijabarkan dengan aman selamanya
\nSelama kami disini, kami dapat lebih jauh berpikir cara was_published_recently(); kenyataannya, dia akan sangat memaslukan jika dalam memperbaiki satu kesalahan kami telah memunculkan yang lain.
Tambah dua lagi cara percobaan ke kelas yang sama, untuk mencoba kebiasaan dari cara lebih menyeluruh:
\ndef test_was_published_recently_with_old_question(self):\n """\n was_published_recently() returns False for questions whose pub_date\n is older than 1 day.\n """\n time = timezone.now() - datetime.timedelta(days=1, seconds=1)\n old_question = Question(pub_date=time)\n self.assertIs(old_question.was_published_recently(), False)\n\ndef test_was_published_recently_with_recent_question(self):\n """\n was_published_recently() returns True for questions whose pub_date\n is within the last day.\n """\n time = timezone.now() - datetime.timedelta(hours=23, minutes=59, seconds=59)\n recent_question = Question(pub_date=time)\n self.assertIs(recent_question.was_published_recently(), True)\nDan sekarang kami mempunyai tiga percobaan yang menegaskan bahwa Question.was_published_recently() mengembalikan nilai bijaksana untuk pertanyaan masa lampau, saat ini, dan masa depan.
Kembali, polls adalah aplikasi minimal, tetapi bagaimanapun itu rumit tumbuh dimasa depan dan apapun kode lain itu berinteraksi, kami sekarang memiliki beberapa jaminan bahwa metode kami memiliki tes tertulis untuk akan berperilaku dengan cara yang diharapkan.
Aplikasi jejak pendapat cukup tidak diskriminatif: dia akan menerbitkan pertanyaan apapun, termasuk satu dimana bidang pub_date terletak di masa depan. Kami harus meningkatkan ini. Pengaturan pub_date di masa depan berarti bahwa Pertanyaan di terbitkan pada saat itu, tetapi tidak terlihat sampai saat itu.
Ketika kami memperbaiki kesalahan diatas, kami menulis percobaan pertama dulu dan kemudian kode untuk memperbaiki itu. Kenyataanya bahwa sebauh contoh dari pengembangan dikendalikan-percobaan, tapi itu tidak masalah bagaimana kita melakukan pekerjaan.
\nDi percobaan pertama anda, kami fokus lebih dekat pada kebiasaan internal dari kode. Untuk percobaan ini, kami ingin memeriksa kebiasaannya seperti akan berpengalaman oleh pengguna melalui perambah jaringan.
\nSebelum kami mencoba memperbaiki apapun, mari kita melihat pada alat di pembuangan kami.
\nDjango menyediakan percobaan Client untuk menirukan antarmuka pengguna dengan kode di tingkatan tampilan. Kami dapat menggunakannya di tests.py atau bahkan di shell.
Kami akan mulai kembali dengan shell, dimana kami butuh melakukan beberapa hal yang tidak diperlukan dalam tests.py. Pertama adalah mensetel lingkungan percobaan dalam shell:
Linux / macOS
$ python manage.py shell\nWindows
...\\> py manage.py shell\n>>> from django.test.utils import setup_test_environment\n>>> setup_test_environment()\nsetup_test_environment() memasang sebuah cetakan pembangun yang mana akan mengizinkan kami menguji beberapa atribut tambahan pada tanggapan seperti response.context yang lain tidak akan tersedia. Catat bahwa cara ini tidak mengatur sebuah percobaan basis data, jadi berikut akan berjalan terhadap basisdata yang ada dan keluaran mungkin sedikit berbeda tergantung pada pertanyaan apa anda sudah buat. And mungkin mendapatkan hasil tidak diharapkan jika TIME_ZONE dalam settings.py tidak benar. Jika anda tidak mengingat pengaturannya terdahulu, periksa itu sebelum melanjutkan.
Selanjutnya kami butuh mengimpor kelas klien percobaan (nanti di tests.py kami akan menggunakan kelas django.test.TestCase, yang datang dengan klien sendirinya, jadi ini tidak akan diwajibkan):
>>> from django.test import Client\n>>> # create an instance of the client for our use\n>>> client = Client()\nDengan itu siap, kami dapat meminta klien melakukan beberapa pekerjaan untuk kami:
\n>>> # get a response from '/'\n>>> response = client.get('/')\nNot Found: /\n>>> # we should expect a 404 from that address; if you instead see an\n>>> # "Invalid HTTP_HOST header" error and a 400 response, you probably\n>>> # omitted the setup_test_environment() call described earlier.\n>>> response.status_code\n404\n>>> # on the other hand we should expect to find something at '/polls/'\n>>> # we'll use 'reverse()' rather than a hardcoded URL\n>>> from django.urls import reverse\n>>> response = client.get(reverse('polls:index'))\n>>> response.status_code\n200\n>>> response.content\nb'\\n <ul>\\n \\n <li><a href="/polls/1/">What's up?</a></li>\\n \\n </ul>\\n\\n'\n>>> response.context['latest_question_list']\n<QuerySet [<Question: What's up?>]>\nDaftar jejak pendapat menunjukkan jejak pendapat yang belum diterbitkan (yaitu itu yang mempunyai pub_date di masa depan). Mari kita perbaiki itu.
Di Tutorial 4 kami memperkenalkan tampilan berdasarkan-kelas, berdasarkan pada ListView:
class IndexView(generic.ListView):\n template_name = 'polls/index.html'\n context_object_name = 'latest_question_list'\n\n def get_queryset(self):\n """Return the last five published questions."""\n return Question.objects.order_by('-pub_date')[:5]\nKami butuh merubah cara get_queryset() dan merubahnya sehingga dia juga memeriksa tanggal dengan membandingkannya dengan timezone.now(). Pertama kami butuh menambahkan sebuah impor:
from django.utils import timezone\ndan lalu kami harus merubah cara get_queryset seperti begitu:
def get_queryset(self):\n """\n Return the last five published questions (not including those set to be\n published in the future).\n """\n return Question.objects.filter(\n pub_date__lte=timezone.now()\n ).order_by('-pub_date')[:5]\nQuestion.objects.filter(pub_date__lte=timezone.now()) mengembalikan queryset mengandung Question dimana pub_date kurang dari atau sama dengan - yaitu, lebih awal dari atau sama dengan - timezone.now.
Sekarang anda dapat memuaskan diri anda sendiri bahwa perilaku ini sesuai diharapkan dengan menyiapkan runserver, memuat situs dalam peramban anda, membuat Questions dengan tanggal dalam lampau dan masa datang, dan memeriksa bahwa hanya itu yang telah diterbitkan yang di daftarkan. Anda tidak ingin melakukan bahwa setiap waktu anda membuat perubahan apapun yang mungkin mempengaruhi ini - jadi mari kita juga membuat percobaan, berdasarkan pada sesi shell kami diatas.
Tambah berikut ke polls/tests.py:
from django.urls import reverse\ndan kami akan membuat fungsi jalan pintas untuk membuat pertanyaan dan juga kelas percobaan baru:
\ndef create_question(question_text, days):\n """\n Create a question with the given `question_text` and published the\n given number of `days` offset to now (negative for questions published\n in the past, positive for questions that have yet to be published).\n """\n time = timezone.now() + datetime.timedelta(days=days)\n return Question.objects.create(question_text=question_text, pub_date=time)\n\n\nclass QuestionIndexViewTests(TestCase):\n def test_no_questions(self):\n """\n If no questions exist, an appropriate message is displayed.\n """\n response = self.client.get(reverse('polls:index'))\n self.assertEqual(response.status_code, 200)\n self.assertContains(response, "No polls are available.")\n self.assertQuerysetEqual(response.context['latest_question_list'], [])\n\n def test_past_question(self):\n """\n Questions with a pub_date in the past are displayed on the\n index page.\n """\n create_question(question_text="Past question.", days=-30)\n response = self.client.get(reverse('polls:index'))\n self.assertQuerysetEqual(\n response.context['latest_question_list'],\n ['<Question: Past question.>']\n )\n\n def test_future_question(self):\n """\n Questions with a pub_date in the future aren't displayed on\n the index page.\n """\n create_question(question_text="Future question.", days=30)\n response = self.client.get(reverse('polls:index'))\n self.assertContains(response, "No polls are available.")\n self.assertQuerysetEqual(response.context['latest_question_list'], [])\n\n def test_future_question_and_past_question(self):\n """\n Even if both past and future questions exist, only past questions\n are displayed.\n """\n create_question(question_text="Past question.", days=-30)\n create_question(question_text="Future question.", days=30)\n response = self.client.get(reverse('polls:index'))\n self.assertQuerysetEqual(\n response.context['latest_question_list'],\n ['<Question: Past question.>']\n )\n\n def test_two_past_questions(self):\n """\n The questions index page may display multiple questions.\n """\n create_question(question_text="Past question 1.", days=-30)\n create_question(question_text="Past question 2.", days=-5)\n response = self.client.get(reverse('polls:index'))\n self.assertQuerysetEqual(\n response.context['latest_question_list'],\n ['<Question: Past question 2.>', '<Question: Past question 1.>']\n )\nMari kita lihat beberapa ini lebih dekat.
\nPertama adalah fungsi jalan pintas pertanyaan, create_question, utuk mengambil beberapa perulangan dari pengolahan membuat pertanyaan.
test_no_questions tidak membuat pertanyaan apapun, tetapi periksa pesan: "Tidak ada jejak pendapat tersedia." dan memeriksa latest_question_list adalah kosong. Catat bahwa kelas django.test.TestCase menyediakan beberapa tambahan metode tuntutan. Dalam contoh ini, kami menggunakan assertContains() dan assertQuerysetEqual().
Dalam test_past_question, kami membuat sebuah pertanyaan dan memeriksa bahwa jika itu muncul dalam daftar.
Dalam test_future_question, kami membuat sebuah pertanyaan dengan pub_date di masa depan. Basisdata disetel kembali untuk setiap metode pengujian, jadi pertanyaan pertama tidak lagi disana, dan kembali indeks jangan mempunyai pertanyaan apapun di dalamnya.
Dan sebagainya, Sebenarnya, kami menggunakan percobaan untuk memberitahu cerita masukan admin dan pengalaman pengguna di situs, dan memeriksa bahwa oada setiap tahapan dan setiap perubahan baru dari sistem, hasil yang diharapkan diterbitkan.
\nDetailViewLink to this heading#Apa yang telah kita kerjakan baik; meskipun pertanyaan masa depan tidak muncul di indeks, pengguna dapat masih mencapai mereka jika mereka tahu atau menebak URL yang tepat. Jadi kami butuh pembatas sama ke DetailView:
class DetailView(generic.DetailView):\n ...\n def get_queryset(self):\n """\n Excludes any questions that aren't published yet.\n """\n return Question.objects.filter(pub_date__lte=timezone.now())\nWe should then add some tests, to check that a Question whose pub_date\nis in the past can be displayed, and that one with a pub_date in the future\nis not:
class QuestionDetailViewTests(TestCase):\n def test_future_question(self):\n """\n The detail view of a question with a pub_date in the future\n returns a 404 not found.\n """\n future_question = create_question(question_text='Future question.', days=5)\n url = reverse('polls:detail', args=(future_question.id,))\n response = self.client.get(url)\n self.assertEqual(response.status_code, 404)\n\n def test_past_question(self):\n """\n The detail view of a question with a pub_date in the past\n displays the question's text.\n """\n past_question = create_question(question_text='Past Question.', days=-5)\n url = reverse('polls:detail', args=(past_question.id,))\n response = self.client.get(url)\n self.assertContains(response, past_question.question_text)\nKami seharusnya untuk menambahkan cara get_queryset mirip ke ResultsView dan membuat kelas percobaan baru untuk tampilan itu. Itu akan sangat mirip pada apa kami telah buat; faktanya akan ada banyak pengulangan.
Kami dapat juga memperbaiki aplikasi kami di cara lain, menambahkan percobaan selama perjalanan. Sebagai contoh, adalah gila bahwa Questions dapat diterbitkan di situs yang tidak mempunyai Choices. Jadi, tampilan kami dapat memeriksa untuk ini, dan tidak menyertakan Questions seperti itu. Percobaan kami akan membuat sebuah``Question`` tanpa Choices dan lalu mencoba bahwa dia tidak diterbitkan, sama halnya membuat Question mirip dengan Choices, dan mencoba bahwa telah diterbitkan.
Mungkin pengguna admin masuk harus diizinkan melihat Questions tidak terbit, tetapi bukan asli pengunjung. Kembali: apapun kebutuhan untuk ditambahkan ke perangkat lunak untuk menyelesaikan ini harus disertai dengan percobaan, apakah anda menulis percobaan dahulu dan lalu membuat kode melewati percobaan, atau bekerja logis di kode anda pertama dan lalu menulis percobaan untuk membuktikannya.
Pada beberapa titik anda terikat untuk melihat percobaan anda dan berharap apakah kode anda menderita dari percobaan gelembung, yang membawa kami kepada:
\nIni mungkin kelihatan bahwa percobaan kami tumbuh tidak terkendali. Pada tingkatan ini akan anda lebih kode di percobaan kami daripada di aplikasi kami, dan pengulangan tidak indah, dibandingkan ke keringkasan elegan dari sisa kode kami.
\nItu tidak masalah. Biarkan mereka tumbuh. Untuk kebanyakan, anda dapat menulis percobaan sekali dan lalu melukapan tentang itu. Itu akan terus melakukan fungsi yang berguna ketika anda melanjutkan mengembangkan program anda.
\nTerkadang percobaan akan butuh diperbaharui. Menduga itu kami merubah tampilan kami sehingga hanya Questions dengan Choices yang diterbitkan. Dalam kasus itu, banyak dari percobaan kami yang ada akan gagal - *katakan ke kami tepatnya percobaan mana butuh dirubah untuk membawanya selalu terbaru, jadi pada tingkatan percobaan itu membantu menjaga diri mereka sendiri.
Yang terburuk, ketika anda melanjutkan mengembangkan, anda mungkin menemukan bahwa anda mempunyai beberapa percobaan yang sekarang berlebihan. Bahkan itu bukan masalah; dalam percobaan adalah hal bagus.
\nSelama percobaan anda menyadari diatur, mereka tidak akan menjadi tidak dapat diatur. Aturan-dari-jempol bagis termasuk mempunyai:
\nterpisah TestClass untuk setiap model atau tampilan
sebuah cara percobaan terpisah untuk setiap kumpulan kondisi anda ingin diuji
Nama cara percobaan yang menggambarkan fungsi mereka
Tutorial ini hanya memperkenalkan beberapa dasar dari percobaan. Terdapat urusan hebat anda dapat lakukan, dan sejumlah alat sangat berguna pada penyelesaian anda untuk mencapai beberapa hal sangat cakap.
\nSebagai contoh, selama percobaan kami telah dicakupi beberapa dari logika internal dari model dan cara tampilan kami menerbitkan informasi, anda dapat menggunakan kerangka "di-perambah" seperti Selenium untuk mencoba cara HTML anda sebenarnya membangun di perambah. Alat ini mengizinkan anda untuk memeriksa bukan hanya kebiasaan kode Django, tetapi juga, sebagai contoh, dari Javascript anda. Ini cukup sesuatu untuk melihat percobaan meluncurkan perambah, dan mulai berinteraksi dengan situs anda, sebagai jika menjadi manusia mengemudikannya! Django menyertakan LiveServerTestCase untuk memfasilitasi dengan alat seperti Selenium.
Jika anda mempunyai aplikasi rumit, anda mungkin ingin menjalankan percobaan otomatis dengan setiap penyerahan untuk tujuan dari perpaduan kelanjutan, sehingga kendali kualitas itu sendiri - setidaknya sebagian - otomatis.
\nSebuah jalan bagus untuk menempatkan bagian belum dicoba dari aplikasi anda adalah memeriksa cakupan kode. Ini juga membantu mencirikan kode rapuh atau bahkan mati. Jika anda tidak dapat mencoba potongan kode, biasanya berarti kode harus diuraikan kembali atau dipindahkan. Cakupan akan membantu mencirikan kode mati. Lihat Perpaduan dengan coverage.py untuk rincian.
\ndoc:Testing in Django </topics/testing/index> mempunyai informasi luas tentang percobaan.
\nUntuk rincian penuh di percobaan, lihat Percobaan di Django.
\nKetika anda nyaman dengan percobaan tampilan Django, baca bagian 6 dari tutorial ini untuk mempelajari tentang pengelolaan berkas statis.
\n