# dokumentasi Django 2.0.8

# Satuan percobaan

Django datang dengan deretan percobaan dia sendiri, di pelipat `tests` dari kode dasar. Itu kebijakan kami untuk memastikan semua percobaan selalu lolos.

Kami menghargai apapun dan semua bantuan pada deretan percobaan!

Percobaan Django semua menggunakan infrastruktur percobaan yang dikirim dengan Django untuk aplikasi percobaan. Lihat Menulis dan menjalankan percobaan untuk sebuah penjelasan bagaimana menulis percobaan baru.

## Menjalankan satuan percobaan

### Mulai cepat

Pertama, fork Django on GitHub.

Kedua, buat dan aktifkan lingkungan maya. Jika anda tidak akrab dengan bagaimana melakukan itu, baca contributing tutorial kami.

Selanjutnya, klon fork anda, pasang beberapa persyaratan, dan jalankan percobaan:

    $ git clone git@github.com:YourGitHubName/django.git django-repo
    $ cd django-repo/tests
    $ pip install -e ..
    $ pip install -r requirements/py3.txt
    $ ./runtests.py

Memasang membutuhkan akan sepertinya membutuhkan beberapa paket sistem operasi dimana komputer anda tidak dipasang. Anda dapat biasanya mencari tahu paket mana untuk dipasang dengan melakukan pencarian Jaringan untuk baris terakhir atau selanjutnya dari pesan kesalahan. Coba menambahkan sistem operasi anda pada permintaan pencarian jika dibutuhkan.

Jika anda mempunyai masalah memasang persyaratan, anda dapat melewatkan langkah itu. Lihat Menjalankan semua percobaan untuk rincian pada memasang pilihan percobaan ketergantungan. Jika anda tidak mempunyai pilihan ketergantungan terpasang, percobaan yang membutuhkan itu akan dilewatkan.

Menjalankan percobaan membutuhkan modul pengaturan Django yang menentukan basisdata untuk digunakan. Untuk membuatnya mudah dijalankan, Django menyediakan dan menggunakan contoh modul pengaturan yang menggunakan basisdata SQLite. Lihat Gunakan modul pengaturan lain untuk mempelajari bagaimana pebedaan modul pengaturan untuk menjalankan percobaan dengan basisdata berbeda.

Pengguna Windows

Kami menganjurkan sesuatu seperti Git Bash untuk menjalankan percobaan menggunakan pendekatan diatas.

Mempunyai masalah? Lihat Menyelesaikan masalah untuk beberapa masalah umum.

### Menjalankan percobaan menggunakan `tox`

Tox adalah sebuah alat untuk menjalankan percobaan dalam lingkungan maya berbeda. Django menyertakan sebuah dasar `tox.ini` yang mengotomatisasi beberapa pemeriksaan peladen yang kami bangun melakukan pada pull request. Untuk menjalankan satuan percobaan dan pemeriksaan lain (seperti import sorting 1, the documentation spelling checker 2, dan code formatting 3), pasang dan jalankan perintah `tox` dari tempat manapun dalam pohon sumber Django:

    $ pip install tox
    $ tox

By default, `tox` runs the test suite with the bundled test settings file for SQLite, `flake8`, `isort`, and the documentation spelling checker. In addition to the system dependencies noted elsewhere in this documentation, the command `python3` must be on your path and linked to the appropriate version of Python. A list of default environments can be seen as follows:

    $ tox -l
    py3
    flake8
    docs
    isort

#### Mencoba versi Python lain dan backend basisdata

Sebagai tambahan ke lingkungan awalan, `tox` mendukung menjalankan rangkaian satuan untuk versi lain dari Python dan backend basisdata lain. Sejak rangkaian percobaan Django tidak menggabungkan sebuah berkas pengaturan untuk backend basisdata selain dari SQLite, bagaimanapun, anda harus create and provide your own test settings. Sebagai contoh, untuk menjalankan percobaan pada Python 3.5 menggunakan PostgreSQL:

    $ tox -e py35-postgres -- --settings=my_postgres_settings

Perintah ini menyetel lingkungan maya Python 3.5, memasang ketergantungan rangkaian percobaan Django (termasuk itu untuk PostgreSQL), dan memanggil `runtests.py` dengan argumen didukung (dalam kasus ini, `--settings=my_postgres_settings`).

Sisa dari dokumentasi ini menunjukkan perintah untuk menjalankan percobaan tanpa `tox`, bagaimanapun, pilihan apapun dilewatkan ke `runtests.py` dapat juga dilewatkan ke `tox` dengan menaruh di awalan daftar argumen dengan `--`, seperti diatas.

Tox juga menghormati variabel lingkungan `DJANGO_SETTINGS_MODULE`, jika disetel. Sebagai contoh, berikut adalah setara pada perintah diatas:

    $ DJANGO_SETTINGS_MODULE=my_postgres_settings tox -e py35-postgres

#### Menjalankan percobaan JavaScript

Django menyertakan sekumpulan dari JavaScript unit tests untuk fungsi-fungsi dalam aplikasi bantuan tertentu. Percobaan JavaScript tidak berjalan secara awalan menggunakan `tox` karena mereka membutuhkan Node.js untuk dipasang dan tidak perlu untuk tambalan-tambalan kebanyakan. Untuk menjalankan percobaan JavaScript menggunakan `tox`:

    $ tox -e javascript

Perintah ini menjalankan `npm install` untuk memastikan persyaratan percobaan terperbaharui dan kemudian menjalankan `npm test`.

### Gunakan modul `pengaturan` lain

Modul pengaturan disertakan (`tests/test_sqlite.py`) mengizinkan anda menjalankan deretan percobaan menggunakan SQLite. Jika anda ingin menjalankan percobaan menggunakan basisdata berbeda, anda akan butuh menentukan berkas pengaturan anda. Beberapa percobaan, seperti itu untuk `contrib.postgres`, adalah khusus untuk backend basisdata tertentu dan akan dilewati jika berjalan dengan backend berbeda.

Untuk menjalankan percobaan dengan pengaturan berbeda, pastikan bahwa modul berada di `PYTHONPATH` anda dan lewati modul dengan `--settings`.

Pengaturan `DATABASES` dalam modul pengaturan percobaan apapun butuh menentukan dua basisdata:

- Basisdata `default`. Basisdata ini harus menggunakan backend yang anda ingin menggunakan untuk percobaan utama.
- Sebuah basisdata dengan nama lain `other`. Basisdata `other` digunakan untuk mencoba permintaan itu dapat dialihkan ke basisdata berbeda. Basisdata ini harus menggunakan backend sama seperti `default`, dan itu harus mempunyai nama berbeda.

Jika anda menggunakan backend yang bukan SQLite, anda akan butuh menyediakan rincian lain untuk setiap basisdata:

- Pilihan `USER` butuh menentukan akun pengguna yang ada ntuk basisdata. Bahwa pengguna butuh perizinan untuk menjalankan `CREATE DATABASE` sehingga basisdata percobaan dapat dibuat.
- Pilihan `PASSWORD` butuh disediakan sandi untuk the `USER` yang telah ditentukan.

Basisdata percobaan mendapatkan nama-nama mereka dengan mengawali `test_` pada nilai dari pengaturan `NAME` untuk basisdata ditentukan di `DATABASES`. Basisdata percobaan ini dihapus ketika percobaan selesai.

Anda akan juga butuh memastikan bahwa basisdata anda menggunakan UTF-8 sebagai kumpulan karakter awal. Jika peladen basisdata anda tidak menggunakan UTF-8 sebagai kumpulan karakter awal, anda akan butuh menyertakan sebuah nilai untuk `CHARSET` di kamus pengaturan untuk basisdata yang berlaku.

### Menjalankan hanya beberapa untuk percobaan

Deretan percobaan keseluruhan Django perlu waktu untuk berjalan, dan menjalankan setiap percobaan tunggal yang dapat berulang jika, katakan, anda cukup menambahkan percobaan pada Django yang anda ingin jalankan secara cepat tanpa menjalankan yang lainnya. Anda dapat menjalankan subkumpulan dari satuan percobaan dengan menambahkan nama-nama dari modul percobaan pada `runtests.py` di baris perintah.

Sebagai contoh, jika anda ingin menjalankan percobaan hanya untuk hubungan umum dan internasionalisasi, ketik:

    $ ./runtests.py --settings=path.to.settings generic_relations i18n

Bagaimana anda menemukan nama-nama dari percobaan perorangan? Lihat di `tests/` — setiap nama pelipat ada nama dari percobaan.

Jika anda hanya ingin menjalankan kelas tertentu dari percobaan, anda dapat menentukan daftar jalur-jalur dari kelas-kelas percobaan perseorangan. Sebagai contoh, untuk menjalankan `TranslationTests` dari modul `i18n`, ketik:

    $ ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests

Melampaui itu, anda dapat menentukan sebuah cara percobaan perorangan seperti ini:

    $ ./runtests.py --settings=path.to.settings i18n.tests.TranslationTests.test_lazy_objects

### Menjalankan percobaan Selenium

Beberapa percobaan membutuhkan Selenium dan perambah Jaringan. Untuk menjalankan percobaan ini, anda harus memasang paket selenium dan menjalankan percobaan dengan pilihan `--selenium=<BROWSERS>`. Sebagai contoh, jika anda mempunyai Firefox dan Google Chrome terpasang:

    $ ./runtests.py --selenium=firefox,chrome

Lihat paket selenium.webdriver untuk daftar perambah tersedia.

Menentukan `--selenium` otomatis menyetel `--tags=selenium` untuk berjalan hanya percobaan yang membutuhkan selenium.

### Menjalankan semua percobaan

Jika anda ingin menjalankan deretan lengkap dari percobaan, anda akan butuh memasang sejumlah ketergantungan:

- argon2-cffi 16.1.0+
- bcrypt
- docutils
- geoip2
- jinja2 2.7+
- numpy
- Pillow
- PyYAML
- pytz (wajib)
- setuptools
- memcached, ditambah supported Python binding
- gettext (gettext pada Windows)
- selenium
- sqlparse

Anda dapat menemukan ketergantungan ini di pip requirements files dalam pelipat `tests/requirements` dari pohon sumber Django dan pasang mereka seperti itu:

    $ pip install -r tests/requirements/py3.txt

Jika anda menjumpai sebuah kesalahan selama pemasangan, sistem anda mungkin kehilangan ketergantungan dari satu atau lebih paket-paket Python. Rundingkan dokumentasi paket-paket gagal atau cari Jaringan dengan pesan kesalahan yang anda jumpai.

Anda dapat juga memasang pencocok basisdata dari pilihan anda menggunakan oracle.txt`, `mysql.txt`, atau `postgres.txt`.

Jika anda ingin mencoba backend penyimpanan memcache, anda akan juga butuh menentukan pengaturan `CACHES` yang menunjuk pada instance memcache anda.

Untuk menjalankan percobaan GeoDjango, anda akan butuh untuk setup a spatial database and install the Geospatial libraries.

Masing-masing ketergantungan ini adalah pilihan. Jika anda kehilangan salah satu dari mereka, percobaan terkait akan dilewati.

### Cakupan kode

Pembantu mendorong menjalankan cakupan pada deretan percobaan untuk mencirikan kawasan yang butuh percobaan tambahan. Pemasangan alat cakupan dan penggunaan digambarkan dalam testing code coverage.

Cakupan harus berjalan di pengolahan tunggal untuk mendapatkan statistik yang tepat. Untuk menjalankan cakupan pada deretan percobaan Django menggunakan pengaturan percobaan biasa:

    $ coverage run ./runtests.py --settings=test_sqlite --parallel=1

Setelah menjalankan cakupan, bangkitkan laporan html dengan menjalankan:

    $ coverage html

Ketika menjalankan cakupan untuk percobaan Django, pengaturan `.coveragerc` yang disertakan menentukan `coverage_html` sebagai pelipat keluaran untuk laporan dan juga mengecualikan beberapa pelipat tidak terkait pada hasil (kode percobaan atau kode dikecualikan disertakan di Django).

## Aplikasi bantuan

Percobaan untuk aplikasi bantuan dapat ditemukan dalam pelipat `tests/`, khususnya dibawah `<app_name>_tests`. Sebagai contoh, percobaan untuk `contrib.auth` ditempatkan dalam `tests/auth_tests`.

## Menyelesaikan masalah

### Banyak percobaan gagal dengan `UnicodeEncodeError`

Jika paket `locales` tidak terpasang, beberapa percobaan akan gagal dengan `UnicodeEncodeError`.

Anda dapat menyelesaikan pada sistem berbasis-Debian, sebagai contoh, dengan menjalankan:

    $ apt-get install locales
    $ dpkg-reconfigure locales

Anda dapat menyelesaikan untuk sistem macOS dengan mengkonfigurasi lokal shell anda:

    $ export LANG="en_US.UTF-8"
    $ export LC_ALL="en_US.UTF-8"

Jalankan perintah `locale` untuk menegaskan perubahan. Pilihannya, tambah perintah ekpos tersebut pada berkas awalan shell anda (sebagai contoh `~/.bashrc` untuk Bash) untuk menghindari mengetik kembali mereka.

### Percobaan hanya gagal di kombinasi

Dalam hal sebuah percobaan lulus ketika berjalan di pemisahan tetapi gagal dalam deretan keseluruhan, kami mempunyai beberapa alat untuk membantu menganalisa masalah.

Pilihan `--bisect` dari `runtests.py` akan menjalankan percobaan kegagalan selama separuh kumpulan percobaan yang dijalankan bersama-sama pada setiap putaran, sering membuatnya memungkinkan untuk mencirikan sejumlah kecil dari percobaan yang mungkin terkait terhadap kegagalan.

Sebagai contoh, andaikan percobaan gagal bekerja dengan sendirinya adalah `ModelTest.test_eq`, lalu gunakan:

    $ ./runtests.py --bisect basic.tests.ModelTest.test_eq

akan mencoba menentukan percobaan yang mencampuri dengan satu yang diberikan. Pertama, percobaan berjalan dengan babak pertama dari deretan percobaan. Jika kegagalan muncul, babak pertama dari deretan percobaan dipisah dalam dua kelompok dan setiap kelompok berjalan dengan percobaan yang ditentukan. Jika tidak ada kegagalan dengan babak pertama dari deretan percobaan, babak kedua dari deretan percobaan berjalan dengan percobaan yang ditentukan dan dipisah dengan benar seperti digambarkan di awal. Pengolahan berulang sampai kumpulan percobaan kegagalan kecil.

Pilihan `--pair` menjalankan percobaan yang diberikan disamping setiap percobaan lain dari deretan, membiarkan anda memeriksa jika percobaan lain mempunyai efek-samping yang menyebabkan kegagal. Jadi:

    $ ./runtests.py --pair basic.tests.ModelTest.test_eq

akan memperbaiki `test_eq` dengan setiap label percobaan.

Dengan kedua `--bisect` dan `--pair`, jika anda sudah menduga kasus mana mungkin bertanggungjawab untuk kegagalan, anda mungkin membatasi percobaan untuk dianalisa silang oleh specifying further test labels setelah satu yang pertama:

    $ ./runtests.py --pair basic.tests.ModelTest.test_eq queries transactions

Anda dapat juga mencoba menjalankan kumpulan apapun dari percobaan dalam membalikkan menggunakan pilihan `--reverse` untuk mengecek bahwa percobaan yang dijalankan di perintah berbeda tidak menyebabkan masalah apapun:

    $ ./runtests.py basic --reverse

### Melihat permintaan SQL berjalan selama percobaan

Jika anda berharap menguji SQL yang sedang berjalan dalam percobaan kegagalan, anda dapat menyalakan SQL logging menggunakan pilihan `--debug-sql`. Jika anda menggabungkan ini dengan `--verbosity=2`, semua permintaan SQL akan mengeluarkan:

    $ ./runtests.py basic --debug-sql

### Melihat melacak kembali penuh dari kegagalan percobaan

Secara awal percobaan berjalan di paralel dengan satu pengolahan per inti. Ketika percobaan berjalan di paralel, bagaimanapun, anda akan hanya melihat pelacakan terpotong untuk tiap kegagalan percobaan. Anda dapat menyesuaikan kebiasaan ini dengan pilihan `--parallel`:

    $ ./runtests.py basic --parallel=1

Anda dapat juga menggunakan variabel lingkungan `DJANGO_TEST_PROCESSES` untuk tujuan ini.

### Tip untuk menulis percobaan

#### Mengasingkan pendaftaran model

Untuk menghindari registrar `apps` global dan mencegah pembuatan tabel tidak diperlukan, model ditentukan dalam cara percobaan harus diikat ke instance `Apps` sementara:

    from django.apps.registry import Apps
    from django.db import models
    from django.test import SimpleTestCase

    class TestModelDefinition(SimpleTestCase):
        def test_model_definition(self):
            test_apps = Apps(['app_label'])

            class TestModel(models.Model):
                class Meta:
                    apps = test_apps
            ...

`django.test.utils.``isolate_apps`(*app_labels, attr_name=None, kwarg_name=None)

Sejak corak ini melibatkan banyak boilerplate, Django menyediakan penghias `isolate_apps()`. Itu digunakan seperti ini:

    from django.db import models
    from django.test import SimpleTestCase
    from django.test.utils import isolate_apps

    class TestModelDefinition(SimpleTestCase):
        @isolate_apps('app_label')
        def test_model_definition(self):
            class TestModel(models.Model):
                pass
            ...

Mengatur `app_label`

Model ditentukan dalam cara percobaan dengan tidak eksplisit `app_label` secara otomatis diberikan label dari aplikasi dimana kelas percobaan mereka ditempatkan.

Untuk memastikan model ditentukan dalam konteks instance `isolate_apps()` dengan benar dipasang, anda harus lolos kumpulan `app_label` ditargetkan sebagai argumen:

tests/app_label/tests.py

    from django.db import models
    from django.test import SimpleTestCase
    from django.test.utils import isolate_apps

    class TestModelDefinition(SimpleTestCase):
        @isolate_apps('app_label', 'other_app_label')
        def test_model_definition(self):
            # This model automatically receives app_label='app_label'
            class TestModel(models.Model):
                pass

            class OtherAppModel(models.Model):
                class Meta:
                    app_label = 'other_app_label'
            ...

Penghias dapat juga diberlakukan ke kelas-kelas:

    from django.db import models
    from django.test import SimpleTestCase
    from django.test.utils import isolate_apps

    @isolate_apps('app_label')
    class TestModelDefinition(SimpleTestCase):
        def test_model_definition(self):
            class TestModel(models.Model):
                pass
            ...

Instance `Apps` sementara digunakan untuk mengasingkan pendaftaran model dapat ditarik sebagai sebuah atribut ketika digunakan sebagai kelas penghias dengan menggunakan parameter `attr_name`:

    from django.db import models
    from django.test import SimpleTestCase
    from django.test.utils import isolate_apps

    @isolate_apps('app_label', attr_name='apps')
    class TestModelDefinition(SimpleTestCase):
        def test_model_definition(self):
            class TestModel(models.Model):
                pass
            self.assertIs(self.apps.get_model('app_label', 'TestModel'), TestModel)

Atau sebagai sebuah argumen pada cara percobaan ketika digunakan sebagai cara penghias dengan menggunakan parameter `kwarg_name`:

    from django.db import models
    from django.test import SimpleTestCase
    from django.test.utils import isolate_apps

    class TestModelDefinition(SimpleTestCase):
        @isolate_apps('app_label', kwarg_name='apps')
        def test_model_definition(self, apps):
            class TestModel(models.Model):
                pass
            self.assertIs(apps.get_model('app_label', 'TestModel'), TestModel)