メインコンテンツへスキップ
見出し画像

テストを制する者は実装を制す


    画像

    AIに頼めば、コードは出てくる。

    しかも速い。人間がコーヒーを一口飲んでいる間に、AIはいくつもファイルと関数を増やし、頼んでいない抽象化まで済ませている。

    問題は、そのコードが正しいかどうかである。

    画面が表示された。エラーが出ない。AIも「実装が完了しました」と言っている。

    しかし、「動いた」は「正しい」と同じではない。

    何をもって正しいとするのか。その基準がなければ、AIはゴールの位置を知らないまま、ものすごい勢いでシュートを打ち続ける。

    入ったかどうかを判定する人はいない。得点板もない。それでもAIは爽やかに報告する。

    「正常に実装できました」

    何を見て言った。

    バスケットボールでは、シュートが外れても、リバウンドを取れば攻撃を続けられる。

    この言葉の面白さは、派手なシュートではなく、その後に残る「次の機会」を勝敗の中心に置いたことだ。

    開発でも、一発ですべて正しく実装できることは少ない。特にAIが書いたコードは、速い代わりに、もっともらしい間違いも速い。

    失敗を受け止め、次の修正へつなげるものが必要になる。

    それがテストである。

    テストを制する者は、実装を制す。

    この記事では、TDDの基本から、良いテストと悪いテストの違い、AI駆動開発でテストを先に書く意味まで、TypeScriptとVitestのコードで説明する。

    テストは、実装後に押す「確認ボタン」ではない

    テストと聞くと、実装が終わった後に品質を確認する作業を想像するかもしれない。

    もちろん、それもテストの役割である。ただ、テストにはもう一つ重要な役割がある。

    実装する前に、「何ができれば完成なのか」を決めることだ。

    たとえば、次の仕様を考える。

    商品合計が5,000円以上なら送料は無料。5,000円未満なら送料は500円。負の金額は不正な入力として拒否する。

    文章としては簡単に見える。しかし、既に境界がある。

    • 4,999円はいくらか

    • 5,000円はいくらか

    • 0円はいくらか

    • -1円はどうするか

    • 小数、`NaN`、`Infinity`を受け入れるか

    テストに置かない条件の挙動は、実装の都合で偶然決まる。より正確には、AIがその場で推測する。

    テストは、その推測を止める。

    import { describe, expect, test } from "vitest";
    import { shippingFee } from "./shipping-fee";
    
    describe("shippingFee", () => {
      test.each([
        { total: 0, expected: 500 },
        { total: 4_999, expected: 500 },
        { total: 5_000, expected: 0 },
      ])("商品合計 $total 円なら送料は $expected 円", ({ total, expected }) => {
        expect(shippingFee(total)).toBe(expected);
      });
    
      test("負の金額は拒否する", () => {
        expect(() => shippingFee(-1)).toThrow("商品合計は0以上");
      });
    });

    このテストは、実装方法を指示していない。

    `if`を使ってもよい。三項演算子でもよい。料金表を別ファイルへ置いてもよい。

    決めているのは、入力に対して外から何が観測できるかだけである。

    つまり、テストは実行できる仕様書になる。

    TDDは「テストをたくさん書くこと」ではない

    TDDはTest-Driven Development、テスト駆動開発の略である。

    中心にあるのは、Red、Green、Refactorという短いサイクルだ。

    Red:まず失敗するテストを書く

    最初に、これから追加したい振る舞いを一つだけテストへ書く。そして実行する。

    まだ実装していないので、テストは失敗する。これがRedである。

    ここで大事なのは、失敗することを実際に確認することだ。

    テストを一度も赤くせず、最初から緑色になった場合、そのテストは既存の振る舞いを確認しているだけかもしれない。もっと悪ければ、何も確認していないかもしれない。

    試合開始前から得点板に100点と表示されていたら、喜ぶ前に配線を疑った方がいい。

    Green:通すための最小限を実装する

    次に、そのテストを通すためのコードを書く。

    export function shippingFee(total: number): number {
      if (total < 0) {
        throw new Error("商品合計は0以上で指定してください");
      }
    
      return total >= 5_000 ? 0 : 500;
    }

    この段階では、未来の拡張を予言しなくてよい。

    都道府県別の送料、会員ランク、離島料金、期間限定キャンペーンを、頼まれてもいないのに先回りして設計する必要はない。未来の自分へ親切なつもりで、現在の自分に巨大な迷路を贈ることになる。

    まず、今あるテストを通す。

    すべての入力を最初のサイクルで決める必要はない。ここでは`NaN`や`Infinity`をどう扱うかは、まだ決めていない。現在は結果として500円を返すが、テストに置いていない以上、これは保証された仕様ではない。業務上の扱いを決め、失敗するテストを書いてから、次のサイクルで実装する。

    Refactor:緑を保ったまま整える

    テストが通った状態で、重複、名前、責務の分け方を見直す。

    外から見える振る舞いは変えない。変えていないことをテストが知らせてくれるから、安心して内部を直せる。

    ここまで終わったら、次の小さな振る舞いについて、またRedへ戻る。

    TDDは、一度に大量のテストを書いてから大量の実装をする手法ではない。

    小さく失敗し、小さく通し、安全な状態で整える。その反復で設計を進める手法である。

    Martin Fowlerの解説でも、テストケースの一覧を考え、テストを一つ書き、失敗させ、通すための実装を行い、必要ならリファクタリングする流れとして説明されている。

    AI駆動開発では、機械判定できる条件はテストが強い

    AIへの指示は自然言語で書ける。速くて便利だが、曖昧さも残る。

    「適切にエラー処理して」

    「境界値も考慮して」

    「いい感じにテストを追加して」

    人間同士でも危険な言葉を、AIへ渡したからといって厳密な仕様にはならない。

    一方、テストは実行できる。

    expect(shippingFee(4_999)).toBe(500);
    expect(shippingFee(5_000)).toBe(0);
    expect(() => shippingFee(-1)).toThrow();

    この3行には、合格と不合格を機械的に分ける力がある。

    AIにとって、テストは次の3役を兼ねる。

    1. 実装前には、完成条件になる

    2. 実装中には、修正のフィードバックになる

    3. 実装後には、変更で壊していないかを検出する

    プロンプトは「こうしてほしい」と伝える。テストは、機械判定できる完成条件について「できたかどうか」を判定する。

    両方あれば強い。ただし、使いやすさ、文章の良し悪し、未知の要件まで、すべてをテストで表せるわけではない。テストが強いのは、期待結果を観測可能な条件へ落とせる領域である。

    悪いテスト1:実装をそのまま書き写す

    次のテストを見てほしい。

    test("10%割引される", () => {
      const price = 10_000;
      expect(discountedPrice(price)).toBe(price - price * 0.1);
    });

    一見、問題なさそうに見える。

    しかし、期待値の計算式が実装と同じだった場合、同じ勘違いを二か所へコピーする可能性がある。

    たとえば仕様が「10%を引き、1円未満は切り捨て」なのに、実装もテストも四捨五入していたら、仲良く緑になる。

    これはテストと実装が互いを検証しているのではない。同じ答案を二枚提出して、答え合わせをした気になっている。

    期待値は、仕様から具体的に置く方がよい。

    test.each([
      { price: 100, expected: 90 },
      { price: 105, expected: 94 },
    ])("$price 円の10%引きは $expected 円", ({ price, expected }) => {
      expect(discountedPrice(price)).toBe(expected);
    });

    実装の式が変わっても、仕様上の答えは変わらない。

    良いテストは、実装コードを翻訳するのではなく、仕様を具体例へ変換する。

    悪いテスト2:判定がふんわりしている

    test("ユーザーを取得できる", async () => {
      const user = await findUser("user-1");
      expect(user).toBeTruthy();
    });

    `toBeTruthy()`が確認するのは、戻り値が真らしいかどうかだけである。

    名前が違っても、メールアドレスが空でも、別人でも、何かオブジェクトが返れば通る。

    選手が体育館に来たことだけ確認し、試合内容は見ていない。

    重要な振る舞いは、具体的に確認する。

    test("IDに対応する公開プロフィールを返す", async () => {
      const user = await findUser("user-1");
    
      expect(user).toEqual({
        id: "user-1",
        displayName: "Sakura",
      });
    });

    ただし、何でも細かく固定すればよいわけではない。作成日時や内部用フラグまで比較すると、関係のない変更で壊れる。

    必要な情報を、必要な精度で確認する。

    悪いテスト3:内部実装と結婚している

    test("送料無料判定を呼ぶ", () => {
      const spy = vi.spyOn(calculator, "isFreeShipping");
    
      calculator.shippingFee(5_000);
    
      expect(spy).toHaveBeenCalledWith(5_000);
    });

    このテストが確認しているのは、送料が無料になることではない。`isFreeShipping`というメソッドが呼ばれたことだ。

    メソッドをインライン化しただけで壊れる。利用者から見える結果は何も変わっていないのに、テストは怒る。

    これはリファクタリングを守るテストではない。リファクタリングへ威嚇射撃するテストである。

    test("5,000円以上なら送料は無料", () => {
      expect(calculator.shippingFee(5_000)).toBe(0);
    });

    外から観測できる振る舞いを確認すれば、内部を自由に変えられる。

    良いテストは実装を固定しない。約束を固定する。

    悪いテスト4:モックだけで世界が完結している

    モックは便利である。

    決済サービス、メール送信、現在時刻など、遅いもの、不安定なもの、実行すると困るものを置き換えられる。Vitestでは`vi.fn()`や`vi.spyOn()`で呼び出しや戻り値を制御できる。

    しかし、何でもモックにすると危険である。

    test("注文を保存する", async () => {
      const repository = {
        findCart: vi.fn().mockResolvedValue(fakeCart),
        saveOrder: vi.fn().mockResolvedValue(undefined),
      };
      const payment = {
        charge: vi.fn().mockResolvedValue({ id: "pay-1" }),
      };
    
      await checkout(repository, payment, "user-1");
    
      expect(repository.findCart).toHaveBeenCalled();
      expect(payment.charge).toHaveBeenCalled();
      expect(repository.saveOrder).toHaveBeenCalled();
    });

    このテストは、各モックが少なくとも一度呼ばれたことしか保証していない。

    決済額が正しいか。保存された注文が支払済みか。空のカートを拒否するか。肝心の約束が見えない。

    本番の部品は一人も出演せず、モック役者だけで学芸会をしている。

    モックの外側に、本物の振る舞いを残す

    モックを使うなら、外部境界を制御しつつ、利用者から見える結果も確認する。

    test("決済に成功した注文を支払済みで保存する", async () => {
      const payment = {
        charge: vi.fn().mockResolvedValue({ id: "pay-1" }),
      };
      const repository = new InMemoryOrderRepository();
    
      const result = await checkout(repository, payment, {
        userId: "user-1",
        total: 1_200,
      });
    
      expect(result).toMatchObject({ status: "paid", paymentId: "pay-1" });
      expect(await repository.find(result.orderId)).toMatchObject({
        userId: "user-1",
        total: 1_200,
        status: "paid",
      });
      expect(payment.charge).toHaveBeenCalledWith(1_200);
    });

    モックの数がゼロなら良い、という話でもない。

    重要なのは、テスト対象の外側にある不安定な境界を置き換え、内側の振る舞いまで偽物にしないことである。

    カバレッジ100%でも、安心は100%ではない

    カバレッジは、コードのどこがテスト中に実行されたかを示す。

    実行されていない場所を見つけるには役立つ。しかし、正しく検証されたかまでは教えてくれない。

    test("送料を計算する", () => {
      shippingFee(5_000);
    });

    このテストでも、`shippingFee`の行は実行される。カバレッジは増える。

    しかし、`expect`がないので何も判定していない。

    コートの白線を100%塗っても、試合に勝ったことにはならない。

    カバレッジは、テスト品質の答えではない。質問を見つけるための地図である。

    数字を見るなら、「通った行」ではなく「守るべき振る舞いが抜けていないか」を一緒に見る必要がある。

    良いテストの条件

    良いテストには、いくつか共通点がある。

    何が壊れたか、名前から分かる

    「正しく動く」ではなく、「5,000円以上なら送料は無料」のように、条件と期待を書く。

    失敗したとき、テスト名だけで調査の入口が分かる。

    一つの振る舞いに集中している

    一つのテストで登録、ログイン、購入、退会まで確認すると、失敗した場所を探すだけで日が暮れる。

    大きな利用者フローはE2Eテストに必要だが、細かな条件まで一試合へ詰め込まない。

    境界値と失敗を含んでいる

    5,000円以上が無料なら、5,000円だけでなく4,999円を見る。

    成功だけでなく、入力不正、権限不足、外部サービスの失敗も見る。

    晴れの日に傘が開いたことだけ確認しても、台風の日に役立つかは分からない。

    実装の詳細ではなく、振る舞いを確認する

    内部の関数名や呼び出し順ではなく、利用者や呼び出し元が受け取る結果を確認する。

    これによって、テストを壊さずに実装を整えられる。

    失敗する理由が一つに絞られている

    データベース、外部API、時刻、乱数、画面をすべて含むテストは、落ちたときに犯人が多すぎる。

    テストの層を分けるとよい。

    | 対象 | 主に確認すること | 向いているテスト |
    |---|---|---|
    | 計算や判定 | 入出力と境界値 | ユニットテスト |
    | DBや外部との接続 | 実際の契約とデータの流れ | 統合テスト |
    | 購入など重要な操作 | 利用者視点の一連の流れ | E2Eテスト |

    全部をユニットテストに押し込む必要も、全部をE2Eで確認する必要もない。

    守りたい約束に合う場所でテストする。

    AIにテストも実装も同時に書かせる危険

    AIへ次のように頼むことがある。

    この機能を実装して、テストも追加してください。

    効率はよい。ただし、AIが仕様を誤解すると、実装とテストが同じ方向へ間違うことがある。

    実装は「5,000円より大きい場合に送料無料」と書き、テストも5,001円しか確認しない。両方とも緑になる。5,000円で壊れるが、二人は気づかない。同じAIなので、実質一人である。

    テストが実装の後に作られると、現在のコードを正解として追認しやすい。

    だから、少なくとも重要な条件は実装より先に決めたい。

    test("ちょうど5,000円なら送料は無料", () => {
      expect(shippingFee(5_000)).toBe(0);
    });

    このテストを先に実行し、意図した理由で失敗することを確認する。その後でAIへ渡す。

    AIにテストを書かせてはいけない、という意味ではない。

    テストケースの候補、抜けている境界、異常系、性質ベーステストの条件など、AIは良い相棒になる。ただし、何が正解かを現在の実装だけから決めさせない。

    正解の根拠は、要件、利用者との約束、業務ルールに置く。

    「まずテストを書け」の実践手順

    AI駆動開発で新しい振る舞いを追加するときは、次の順番で進める。

    1. 実装ではなく、利用者から見える変化を一文で書く

    2. 代表例、境界値、失敗条件を挙げる

    3. 最初の一例だけをテストにする

    4. 実行して、意図した理由で失敗することを確認する

    5. AIへテストと必要な文脈を渡し、通すための最小実装を依頼する

    6. 全テストを実行する

    7. 緑の状態で、名前、重複、責務を整える

    8. 次の振る舞いについてRedへ戻る

    ここで「意図した理由で失敗する」が重要である。

    モジュールが見つからない、テスト環境が壊れている、データベースへ接続できない。これらも画面は赤くなるが、期待したRedではない。

    送料無料になるはずなのに500円を返した。そのように、追加したい振る舞いがまだ存在しないために失敗していることを確認する。

    テストのテストである。

    少し面倒に見える。しかし、この数十秒を惜しむと、何も検証していないテストを何年も守ることになる。

    ベンチに知らない人が座っていても、ユニフォームを着ているだけで選手だと思わない方がいい。

    すべてをTDDで書く必要はない

    TDDは強力だが、宗教ではない。

    見た目を探る試作、使い捨ての調査コード、正解そのものがまだ分からない実験では、先にコードを書いた方が学びやすいこともある。

    その場合も、分かったことを本番へ移す段階では、守りたい振る舞いをテストへ置く。

    逆に、次のような場所ではテストファーストの価値が高い。

    • 境界値がある計算

    • 認可や権限

    • 金額や請求

    • データ変換

    • 障害時のフォールバック

    • 過去に壊れた不具合の再発防止

    • AIが大きく書き換える予定のコード

    間違えたときの損失が大きいほど、先にゴールを置く意味がある。

    テストを制する者は実装を制す

    AIは、コードを書く速さを大きく変えた。

    しかし、速く書けることと、正しく作れることの間には距離がある。

    その距離を埋めるのがテストである。

    良いテストは、実装の後ろを歩いて間違いを探すだけではない。

    実装の前にゴールを置く。

    境界を決める。

    失敗を受け止める。

    内部を安心して変えられる場所を作る。

    そして、AIが「できました」と言ったときに、本当にできたかを答える。

    コードを書く人が実装を制するとは限らない。

    何をもって完成とするかを決め、その基準を実行できる形にした人が、実装を制する。

    まず、テストを書こう。

    参考資料

     
     
    Web開発4年|AIで小さなサービスを作って検証しています。開発期間・PV・登録者・売上・失敗まで全部公開。「作れる。でも売れない。」の理由を研究中。失敗と記録を、次の人の資産に。

    あなたへのおすすめ