# dokumentasi Django 2.2.9.dev20191202104323

# Menulis aplikasi Django pertama anda, bagian 5

Tutorial ini mulai dimana Tutorial 4 ditinggalkan. Kami telah membangun aplikasi jejak pendapat jaringan, dan kami akan sekarang membuat otomatis percobaan untuknya.

## Memperkenalkan percobaan otomatis

### Apakah percobaan otomatis?

Percobaan adalah kebiasaan sederhana yang memeriksa pekerjaan dari kode anda.

Percobaan 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.

### Mengapa anda butuh membuat percobaan

Jadi mengapa membuat percobaan, dan jenapa sekarang?

Anda 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.

#### Percobaan akan menyelematkan waktu anda

Sampai titik tertentu, 'memeriksa itu kelihatannya bekerja' akan menjadi percobaan memuaskan. Di lebih aplikasi menakjubkan, anda mungkin mempunyai lusinan interaksi rumit antara komponen.

Sebuah perubahan di siapapun dari komponen itu dapat mempunyai konsekuensi tidak diharaokan di kebiasaan aplikasi. Memeriksa itu dia 'kelihatan bekerja' dapt berarti melalui fungsi kode anda dengan 20 macam berbeda dari data percobaan anda hanya untuk memastikan anda tidak merusak sesuatu - tidak baik menggunakan waktu anda.

Itu 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.

Terkadang 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.

Bagaimanapun, 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.

#### Percobaan tidak hanya mencirikan masalah, mereka mencegah masalah

Adalah sebuah kesalahan berpikir percobaan hanya aspek negatif dari pengembangan.

Tanpa 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.

Percobaan 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.

#### Percobaan membuat kode anda lebih menarik

Anda mungkin telah membuat potongan hebat dari perangkat lunak, tetapi anda akan menemukan bahwa banyak pengembang lain akan dengan mudah menolak untuk melihatnya karena dia kurang percobaan; tanpa percobaan, mereka tidak akan mempercayainya. Jacob Kaplan-Moss, satu dari pengembang Django, mengatakan "Kode tanpa percobaan adalah rusak oleh rancangan."

Bahwa pengembang lain ingin melihat percobaan di perangkat lunak anda sebelum mereka mengambilnya secara sungguh-sungguh adalah alasan lain untuk anda untuk memulai menulis percobaan.

#### Percobaan membantu tim bekerja bersama

Titik 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!

## Strategi percobaan dasar

Terdapat banyak cara untuk mendekatkan penulisan percobaan

Beberapa pemrogram mengikuti ketertiban dipanggil "test-driven development"; mereka sebenarnya menulis percobaan mereka sebelum mereka menulis kode mereka. Ini mungkin kelihatan kontra-intuitif, tetapi kenyataannya dia mirip pada apa yang paling orang sering lakukan: mereka menggambarkan masalah, lalu membuat beberapa kode untuk mengatasinya. Pengembangan uji-coba dengan mudah menyusun masalah di kasus percobaan Phyton.

Lebih 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.

Terkadang 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.

Jadi mari kita melakukannya segera.

## Menulis percobaan pertama kami

### Kami mencirikan kesalahan

Untungnya, 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:

/ 

    $ python manage.py shell

    ...\> py manage.py shell

    >>> import datetime
    >>> from django.utils import timezone
    >>> from polls.models import Question
    >>> # create a Question instance with pub_date 30 days in the future
    >>> future_question = Question(pub_date=timezone.now() + datetime.timedelta(days=30))
    >>> # was it published recently?
    >>> future_question.was_published_recently()
    True

Sejak hal-hal di masa depan tidak 'baru terjadi', hal ini jelaslah salah.

### Buat percobaan untuk membuka kesalahan

Apa 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` :

polls/tests.py

    import datetime

    from django.test import TestCase
    from django.utils import timezone

    from .models import Question

    class QuestionModelTests(TestCase):

        def test_was_published_recently_with_future_question(self):
            """
            was_published_recently() returns False for questions whose pub_date
            is in the future.
            """
            time = timezone.now() + datetime.timedelta(days=30)
            future_question = Question(pub_date=time)
            self.assertIs(future_question.was_published_recently(), False)

Disini 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.

### Menjalankan percobaan

Pada terminal, kita dapat menjalankan percobaan kita:

/ 

    $ python manage.py test polls

    ...\> py manage.py test polls

dan anda akan lihat sesuatu seperti:

    Creating test database for alias 'default'...
    System check identified no issues (0 silenced).
    F
    ======================================================================
    FAIL: test_was_published_recently_with_future_question (polls.tests.QuestionModelTests)
    ----------------------------------------------------------------------
    Traceback (most recent call last):
      File "/path/to/mysite/polls/tests.py", line 16, in test_was_published_recently_with_future_question
        self.assertIs(future_question.was_published_recently(), False)
    AssertionError: True is not False

    ----------------------------------------------------------------------
    Ran 1 test in 0.001s

    FAILED (failures=1)
    Destroying test database for alias 'default'...

Kesalahan berbeda?

If instead you're getting a `NameError` here, you may have missed a step in Part 2 where we added imports of `datetime` and `timezone` to `polls/models.py`. Copy the imports from that section, and try running your tests again.

Apa yang terjadi adalah ini:

- `manage.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.

### Memperbaiki kesalahan

Kami 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:

polls/models.py

    def was_published_recently(self):
        now = timezone.now()
        return now - datetime.timedelta(days=1) <= self.pub_date <= now

dan jalankan percobaan kembali:

    Creating test database for alias 'default'...
    System check identified no issues (0 silenced).
    .
    ----------------------------------------------------------------------
    Ran 1 test in 0.001s

    OK
    Destroying test database for alias 'default'...

Setelah mengenali sebuah bug, kami menulis tes untuk menemukannya dan memperbaiki bug yang ada di dalam kode sehingga tes yang kami buat dapat berjalan lancar.

Banyak hal lain mungkin menjadi salah dengan aplikasi kami di masa depan, tetapi kami dapat memastikan bahwa tidak secara sengaja memunculkan kembali kesalahan ini, karena menjalankan percobaan akan memerpingati kami segera. Kami dapat mempertimbangkan bagian kecil ini dari aplikasi berpikir dengan aman selamanya.

### Percobaan lebih luas

Selama 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:

polls/tests.py

    def test_was_published_recently_with_old_question(self):
        """
        was_published_recently() returns False for questions whose pub_date
        is older than 1 day.
        """
        time = timezone.now() - datetime.timedelta(days=1, seconds=1)
        old_question = Question(pub_date=time)
        self.assertIs(old_question.was_published_recently(), False)

    def test_was_published_recently_with_recent_question(self):
        """
        was_published_recently() returns True for questions whose pub_date
        is within the last day.
        """
        time = timezone.now() - datetime.timedelta(hours=23, minutes=59, seconds=59)
        recent_question = Question(pub_date=time)
        self.assertIs(recent_question.was_published_recently(), True)

Dan sekarang kami mempunyai tiga percobaan yang menegaskan bahwa `Question.was_published_recently()` mengembalikan nilai bijaksana untuk pertanyaan masa lampau, saat ini, dan masa depan.

Lagi, `polls` adalah aplikasi sederhana, tetapi bagaimanapun rumit dia tumbuh di masa depan dan apapun kdoe lain yang berinteraksi dengan nya, kami sekarang mempunyai beberapa jaminan bahwa cara kami telah tulis percobaan untuk akan berperilaku di jalur yang diharapkan.

## Percobaan tampilan

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.

### Sebuah percobaan untuk tampilan

Ketika kami memperbaiki kesalahan diatas, kami menulis percobaan dahulu dan lalu kode untuk memperbaikinya. Kenyataannya bahwa sebuah contoh sederhana dari pengembangan uji-coba, tetapi dia tidak terlalu penting urutan mana kami melakukan pekerjaan.

Di 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.

Sebelum kami mencoba memperbaiki apapun, mari kita melihat pada alat di pembuangan kami.

### Klien percobaan Django

Django 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`:

/ 

    $ python manage.py shell

    ...\> py manage.py shell

    >>> from django.test.utils import setup_test_environment
    >>> setup_test_environment()

`setup_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
    >>> # create an instance of the client for our use
    >>> client = Client()

Dengan itu siap, kami dapat meminta klien melakukan beberapa pekerjaan untuk kami:

    >>> # get a response from '/'
    >>> response = client.get('/')
    Not Found: /
    >>> # we should expect a 404 from that address; if you instead see an
    >>> # "Invalid HTTP_HOST header" error and a 400 response, you probably
    >>> # omitted the setup_test_environment() call described earlier.
    >>> response.status_code
    404
    >>> # on the other hand we should expect to find something at '/polls/'
    >>> # we'll use 'reverse()' rather than a hardcoded URL
    >>> from django.urls import reverse
    >>> response = client.get(reverse('polls:index'))
    >>> response.status_code
    200
    >>> response.content
    b'\n    <ul>\n    \n        <li><a href="/polls/1/">What&#39;s up?</a></li>\n    \n    </ul>\n\n'
    >>> response.context['latest_question_list']
    <QuerySet [<Question: What's up?>]>

### Memperbaiki tampilan kami

Daftar 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`:

polls/views.py

    class IndexView(generic.ListView):
        template_name = 'polls/index.html'
        context_object_name = 'latest_question_list'

        def get_queryset(self):
            """Return the last five published questions."""
            return Question.objects.order_by('-pub_date')[:5]

Kami butuh merubah cara `get_queryset()` dan merubahnya sehingga dia juga memeriksa tanggal dengan membandingkannya dengan `timezone.now()`. Pertama kami butuh menambahkan sebuah impor:

polls/views.py

    from django.utils import timezone

dan lalu kami harus merubah cara `get_queryset` seperti begitu:

polls/views.py

    def get_queryset(self):
        """
        Return the last five published questions (not including those set to be
        published in the future).
        """
        return Question.objects.filter(
            pub_date__lte=timezone.now()
        ).order_by('-pub_date')[:5]

`Question.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`.

### Menguji tampilan baru kami

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`:

polls/tests.py

    from django.urls import reverse

dan kami akan membuat fungsi jalan pintas untuk membuat pertanyaan dan juga kelas percobaan baru:

polls/tests.py

    def create_question(question_text, days):
        """
        Create a question with the given `question_text` and published the
        given number of `days` offset to now (negative for questions published
        in the past, positive for questions that have yet to be published).
        """
        time = timezone.now() + datetime.timedelta(days=days)
        return Question.objects.create(question_text=question_text, pub_date=time)

    class QuestionIndexViewTests(TestCase):
        def test_no_questions(self):
            """
            If no questions exist, an appropriate message is displayed.
            """
            response = self.client.get(reverse('polls:index'))
            self.assertEqual(response.status_code, 200)
            self.assertContains(response, "No polls are available.")
            self.assertQuerysetEqual(response.context['latest_question_list'], [])

        def test_past_question(self):
            """
            Questions with a pub_date in the past are displayed on the
            index page.
            """
            create_question(question_text="Past question.", days=-30)
            response = self.client.get(reverse('polls:index'))
            self.assertQuerysetEqual(
                response.context['latest_question_list'],
                ['<Question: Past question.>']
            )

        def test_future_question(self):
            """
            Questions with a pub_date in the future aren't displayed on
            the index page.
            """
            create_question(question_text="Future question.", days=30)
            response = self.client.get(reverse('polls:index'))
            self.assertContains(response, "No polls are available.")
            self.assertQuerysetEqual(response.context['latest_question_list'], [])

        def test_future_question_and_past_question(self):
            """
            Even if both past and future questions exist, only past questions
            are displayed.
            """
            create_question(question_text="Past question.", days=-30)
            create_question(question_text="Future question.", days=30)
            response = self.client.get(reverse('polls:index'))
            self.assertQuerysetEqual(
                response.context['latest_question_list'],
                ['<Question: Past question.>']
            )

        def test_two_past_questions(self):
            """
            The questions index page may display multiple questions.
            """
            create_question(question_text="Past question 1.", days=-30)
            create_question(question_text="Past question 2.", days=-5)
            response = self.client.get(reverse('polls:index'))
            self.assertQuerysetEqual(
                response.context['latest_question_list'],
                ['<Question: Past question 2.>', '<Question: Past question 1.>']
            )

Mari kita lihat beberapa ini lebih dekat.

Pertama 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.

### Menguji `DetailView`

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`:

polls/views.py

    class DetailView(generic.DetailView):
        ...
        def get_queryset(self):
            """
            Excludes any questions that aren't published yet.
            """
            return Question.objects.filter(pub_date__lte=timezone.now())

Dan tentu saja, kami akan menambahkan beberapa percobaan, utuk memeriksa `Question` itu yang `pub_date` berada di masa lampau dapat ditampilkan, dan satu itu dengan `pub_date` di masa datang tidak:

polls/tests.py

    class QuestionDetailViewTests(TestCase):
        def test_future_question(self):
            """
            The detail view of a question with a pub_date in the future
            returns a 404 not found.
            """
            future_question = create_question(question_text='Future question.', days=5)
            url = reverse('polls:detail', args=(future_question.id,))
            response = self.client.get(url)
            self.assertEqual(response.status_code, 404)

        def test_past_question(self):
            """
            The detail view of a question with a pub_date in the past
            displays the question's text.
            """
            past_question = create_question(question_text='Past Question.', days=-5)
            url = reverse('polls:detail', args=(past_question.id,))
            response = self.client.get(url)
            self.assertContains(response, past_question.question_text)

### Ide untuk percobaan lebih

Kami 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:

## Ketika percobaan, lebih baik

Ini 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.

Itu 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.

Terkadang 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.

Selama percobaan anda menyadari diatur, mereka tidak akan menjadi tidak dapat diatur. Aturan-dari-jempol bagis termasuk mempunyai:

- terpisah `TestClass` untuk setiap model atau tampilan
- sebuah cara percobaan terpisah untuk setiap kumpulan kondisi anda ingin diuji
- Nama cara percobaan yang menggambarkan fungsi mereka

## Percobaan lebih jauh

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.

Sebagai 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.

Sebuah 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.

doc:Testing in Django </topics/testing/index> mempunyai informasi luas tentang percobaan.

## Apa Selanjutnya?

Untuk rincian penuh di percobaan, lihat Percobaan di Django.

Ketika anda nyaman dengan percobaan tampilan Django, baca bagian 6 dari tutorial ini untuk mempelajari tentang pengelolaan berkas statis.