プロパティベーステスト実践 — 例示テストが捕まえられないバグを捕まえる方法

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

+--------------+     +--------------+     +-----------+     +--------------+
| プロパティ定義 | --> | ジェネレーター | --> | プロパティ  | --> | 合格: 繰り返し |
| 「すべてのxに  |     | がランダム入力 |     | 検査       |     | (既定100回)  |
|  対してP(x)」 |     | を生成        |     | (assert)  |     +--------------+
+--------------+     +--------------+     +-----+-----+
                                               | 失敗
                                               v
                                    +---------------------+
                                    | シュリンキング:       |
                                    | 失敗を保ったまま      |
                                    | 入力を最小化          |
                                    +----------+----------+
                                               v
                                    「最小反例: x = 0」を報告

# cart.py
from decimal import Decimal, ROUND_HALF_UP


def apply_discount(total_cents: int, discount_percent: int) -> int:
    """合計(セント)に割引率(0-100)を適用してセント単位に丸める。"""
    if not 0 <= discount_percent <= 100:
        raise ValueError("discount_percent must be between 0 and 100")
    if total_cents < 0:
        raise ValueError("total_cents must be non-negative")
    discounted = Decimal(total_cents) * (Decimal(100 - discount_percent) / Decimal(100))
    return int(discounted.quantize(Decimal("1"), rounding=ROUND_HALF_UP))

# test_cart.py
from hypothesis import given, settings, strategies as st
from cart import apply_discount


@given(total=st.integers(min_value=0, max_value=10**12),
       pct=st.integers(min_value=0, max_value=100))
def test_discount_never_negative_and_never_exceeds_total(total, pct):
    result = apply_discount(total, pct)
    # 不変条件1: 割引結果は負になり得ない
    assert result >= 0
    # 不変条件2: 割引結果は元の合計を超えられない
    assert result <= total


@given(total=st.integers(min_value=0, max_value=10**12))
def test_zero_discount_is_identity(total):
    # 事後条件: 0%割引は恒等関数である
    assert apply_discount(total, 0) == total


@given(total=st.integers(min_value=0, max_value=10**12))
def test_full_discount_is_zero(total):
    # 事後条件: 100%割引は常に0である
    assert apply_discount(total, 100) == 0


@given(total=st.integers(min_value=0, max_value=10**12),
       pct=st.integers(min_value=0, max_value=100))
def test_discount_is_monotonic(total, pct):
    # 不変条件3: 割引率が大きいほど結果は小さいか等しい
    if pct < 100:
        assert apply_discount(total, pct + 1) <= apply_discount(total, pct)

# 有効な注文オブジェクトを生成する戦略
order_strategy = st.builds(
    dict,
    order_id=st.uuids().map(str),
    items=st.lists(
        st.builds(dict,
                  sku=st.text(alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", min_size=8, max_size=8),
                  qty=st.integers(min_value=1, max_value=999),
                  unit_price_cents=st.integers(min_value=1, max_value=10**7)),
        min_size=1, max_size=50,
    ),
)


@given(order=order_strategy)
def test_order_total_equals_sum_of_lines(order):
    total = calculate_order_total(order)
    expected = sum(i["qty"] * i["unit_price_cents"] for i in order["items"])
    assert total == expected

import net.jqwik.api.*;
import net.jqwik.api.constraints.*;
import static org.assertj.core.api.Assertions.assertThat;

class CsvCodecProperties {

    @Property
    void encodeThenDecodeIsIdentity(@ForAll @StringLength(max = 200) String field) {
        // ラウンドトリップ: どんな文字列もエンコード後にデコードすれば元どおり
        String encoded = CsvCodec.encodeField(field);
        String decoded = CsvCodec.decodeField(encoded);
        assertThat(decoded).isEqualTo(field);
    }

    @Property
    void encodedFieldNeverBreaksRowStructure(
            @ForAll @Size(min = 1, max = 10) List<@StringLength(max = 50) String> fields) {
        // 不変条件: フィールドにカンマ/改行/引用符があっても行構造が維持される
        String row = CsvCodec.encodeRow(fields);
        List<String> parsed = CsvCodec.parseRow(row);
        assertThat(parsed).isEqualTo(fields);
    }

    @Property
    void normalizeIsIdempotent(@ForAll String input) {
        // 冪等性: 正規化を2回しても1回と同じ
        String once = CsvCodec.normalize(input);
        String twice = CsvCodec.normalize(once);
        assertThat(twice).isEqualTo(once);
    }

    @Provide
    Arbitrary<String> japaneseText() {
        // カスタムジェネレーター: ひらがな・カタカナ範囲を含む文字列
        return Arbitraries.strings()
                .withCharRange('あ', 'ん')
                .withCharRange('ア', 'ン')
                .withCharRange('a', 'z')
                .ofMaxLength(100);
    }

    @Property
    void roundTripWithJapanese(@ForAll("japaneseText") String field) {
        assertThat(CsvCodec.decodeField(CsvCodec.encodeField(field))).isEqualTo(field);
    }
}

import fc from "fast-check";
import { describe, it } from "vitest";
import { mergeIntervals } from "../src/intervals";

// 参照実装: 遅いが明らかに正しいバージョン
function mergeIntervalsNaive(intervals: Array<[number, number]>): Array<[number, number]> {
  const points = new Set<number>();
  for (const [s, e] of intervals) {
    for (let i = s; i < e; i++) points.add(i);
  }
  // 連続区間に再グループ化 (小さな範囲でのみ使用)
  const sorted = [...points].sort((a, b) => a - b);
  const out: Array<[number, number]> = [];
  for (const p of sorted) {
    const last = out[out.length - 1];
    if (last && last[1] === p) last[1] = p + 1;
    else out.push([p, p + 1]);
  }
  return out;
}

describe("mergeIntervals", () => {
  it("最適化実装はナイーブ実装と常に同じ結果を出す", () => {
    fc.assert(
      fc.property(
        fc.array(
          fc.tuple(fc.integer({ min: 0, max: 100 }), fc.integer({ min: 0, max: 100 }))
            .map(([a, b]) => (a <= b ? [a, b] : [b, a]) as [number, number]),
          { maxLength: 30 }
        ),
        (intervals) => {
          const fast = mergeIntervals(intervals);
          const slow = mergeIntervalsNaive(intervals);
          return JSON.stringify(fast) === JSON.stringify(slow);
        }
      )
    );
  });

  it("結果の区間は常にソートされており重ならない", () => {
    fc.assert(
      fc.property(
        fc.array(fc.tuple(fc.nat(1000), fc.nat(1000)), { maxLength: 50 }),
        (raw) => {
          const intervals = raw.map(([a, b]) => (a <= b ? [a, b] : [b, a]) as [number, number]);
          const merged = mergeIntervals(intervals);
          for (let i = 1; i < merged.length; i++) {
            // 不変条件: 前の区間の終わり < 次の区間の始まり
            if (merged[i - 1][1] >= merged[i][0]) return false;
          }
          return true;
        }
      )
    );
  });
});

# Hypothesis: 失敗した反例は .hypothesis/examples ディレクトリに自動保存され、
# 次の実行で最初に再試行される (反例データベース)

# 特定の反例を恒久的な回帰テストとして釘付けにすることもできる
from hypothesis import example

@given(st.text())
@example("")          # 過去に失敗した反例を明示的に固定
@example("\x00")
def test_normalize_roundtrip(s):
    assert denormalize(normalize(s)) == s

// jqwik: 失敗時にシードが出力され、同じシードで再現できる
@Property(seed = "8723648723648")
void reproducesFailure(@ForAll String input) { /* ... */ }
// jqwikも失敗サンプルを .jqwik-database に保存し、次の実行で優先的に再試行する

// fast-check: 失敗レポートにseedとpathが出力される
fc.assert(prop, { seed: 1042, path: "0:0:1" }); // 正確にその反例から再実行

# LRUキャッシュをdictモデルと対照するステートマシンテスト (Hypothesis)
from hypothesis import strategies as st
from hypothesis.stateful import RuleBasedStateMachine, rule, invariant
from lru import LRUCache

CAPACITY = 8


class LRUCacheMachine(RuleBasedStateMachine):
    def __init__(self):
        super().__init__()
        self.real = LRUCache(capacity=CAPACITY)
        self.model = {}   # モデル: 順序を覚えるdict (Pythonのdictは挿入順を保持)

    @rule(key=st.integers(0, 20), value=st.integers())
    def put(self, key, value):
        self.real.put(key, value)
        self.model.pop(key, None)
        self.model[key] = value
        if len(self.model) > CAPACITY:
            oldest = next(iter(self.model))
            del self.model[oldest]

    @rule(key=st.integers(0, 20))
    def get(self, key):
        expected = self.model.get(key)
        if expected is not None:
            # モデル側でも最近使用として更新
            self.model.pop(key)
            self.model[key] = expected
        assert self.real.get(key) == expected

    @invariant()
    def size_never_exceeds_capacity(self):
        assert self.real.size() <= CAPACITY


TestLRUCache = LRUCacheMachine.TestCase

# Hypothesis: プロファイルでローカル/CI/夜間を分離
from hypothesis import settings, HealthCheck

settings.register_profile("dev", max_examples=50)
settings.register_profile("ci", max_examples=200, deadline=None,
                          suppress_health_check=[HealthCheck.too_slow])
settings.register_profile("nightly", max_examples=2000)
# 実行時: HYPOTHESIS_PROFILE=ci pytest