Elixir & Phoenix: Scalable Backend Development · Pelajaran

Pengujian Berbasis Properti dengan StreamData

Melampaui pengujian berbasis contoh dengan menghasilkan ratusan input acak menggunakan StreamData untuk menemukan kasus batas yang tidak ditemukan contoh ExUnit.

Pelajaran 4 dari 413 langkah

Pengujian Berbasis Properti dengan StreamData adalah pelajaran Elixir & Phoenix: Scalable Backend Development gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Elixir & Phoenix: Scalable Backend Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

What is Property-Based Testing?

Traditional tests check specific examples. Property-based testing describes a rule that should hold for all inputs, then generates many random inputs to try to break it.

It excels at finding edge cases you never thought to write by hand.

Adding StreamData

StreamData is the Elixir library for generating test data. Add it to your dependencies.

defp deps do
  [{:stream_data, "~> 0.6", only: :test}]
end

Importing the Helpers

Use ExUnitProperties in your test module to unlock the check all and property macros.

defmodule MyApp.MathTest do
  use ExUnit.Case
  use ExUnitProperties
end

Writing a Property

The property macro replaces test. Inside, check all draws values from a generator and runs the body for each.

property "reversing twice returns the original list" do
  check all list <- list_of(integer()) do
    assert Enum.reverse(Enum.reverse(list)) == list
  end
end

Built-in Generators

StreamData provides generators for common types:

integer(), float(), boolean()
string(:alphanumeric)
list_of/1, map_of/2

check all name <- string(:alphanumeric), age <- integer(0..120) do
  assert build_user(name, age).age >= 0
end

Combining Generators

Use tuple/1 or bind multiple generators in one check all to produce structured data.

check all {a, b} <- tuple({integer(), integer()}) do
  assert a + b == b + a
end

Transforming with map

StreamData.map/2 reshapes generated values, e.g. building positive integers from any integer.

positive = StreamData.map(integer(), &abs/1)
check all n <- positive do
  assert n >= 0
end

Filtering Inputs

filter/2 discards values that do not match a condition. Use it sparingly — heavy filtering slows generation.

non_zero = StreamData.filter(integer(), &(&1 != 0))
check all d <- non_zero do
  assert div(d, d) == 1
end

Shrinking Failures

When a property fails, StreamData shrinks the input — repeatedly simplifying it — to report the smallest failing example. This makes debugging far easier than a random huge value.

Choosing Good Properties

Effective properties describe invariants rather than restating the implementation:

Round-trip: encode then decode returns the original
Idempotency: applying twice equals applying once
Invariants: a sorted list is always ordered

When to Use It

Property tests complement, not replace, example tests. Reach for them on pure functions, parsers, serializers, and data transformations where many inputs share one rule.

Quick Check

Test your property-based testing knowledge.

Jawab di pelajaran interaktif

Recap

You learned property-based testing with StreamData:

Describe rules that hold for all inputs
Use property + check all with generators
Combine, map, and filter generators
Shrinking reports the minimal failing case
Best for invariants, round-trips, and idempotency

It uncovers edge cases example tests miss.

Gratis untuk memulai

Belajar Elixir dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 12
Pelajaran: 48

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pengujian Berbasis Properti dengan StreamData” gratis?

Ya — teks lengkap “Pengujian Berbasis Properti dengan StreamData” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Elixir & Phoenix: Scalable Backend Development, upgrade ke CoddyKit PRO. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pengujian Berbasis Properti dengan StreamData”?

Melampaui pengujian berbasis contoh dengan menghasilkan ratusan input acak menggunakan StreamData untuk menemukan kasus batas yang tidak ditemukan contoh ExUnit. Kamu berlatih Elixir & Phoenix: Scalable Backend Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Elixir & Phoenix: Scalable Backend Development?

Tidak diperlukan pengalaman sebelumnya. Elixir & Phoenix: Scalable Backend Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pengujian Berbasis Properti dengan StreamData” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Elixir & Phoenix: Scalable Backend Development ini?

Ya. Setiap pelajaran Elixir & Phoenix: Scalable Backend Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Pengujian Unit dengan ExUnit
Pengujian Integrasi Aplikasi Phoenix
Mock, Stub, dan Data Pengujian
Pengujian Berbasis Properti dengan StreamData

← Kembali ke Elixir & Phoenix: Scalable Backend Development