デザインパターンとDI — テストが書けないのは設計のせい

デザインパターンとDI。外から差し込む交換可能な部品と組み立てたアプリの箱、テストのチェック。

テストが書けないのは、腕ではなく設計の問題です。デザインパターンとDIで、差し替えられる形に直します。

前回: プロセスとスレッドと競合状態 — たまにだけ数が合わない

これは【深掘り】の記事です。本線の順路ではありません。 このシリーズは言葉を覚える回にしません。 全部、手元で書いて、走らせて、出力を出します。 飛ばしても本線は進めます。 本線側の「テストの書き方」は className でテストしない — Vitestで書くReactのテスト にあります。

この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows の PowerShell ではありません。VM の立て方は VMを29台溜めた話 — Ubuntu Serverの立て方 にあります。

Node.js が入っていることが前提です。 node -v で v20 以上が出ればそのまま進めます。 この記事のテストは node --test(Node.js に最初から入っているテスト実行機能) だけを使います。 npm install は一度もしません。


「デザインパターンを覚えたら設計がうまくなる」と思っていました。

23個のパターン名を一通り読みました。名前は覚えました。それで書けるようになったかというと、逆でした。

自分のコードに片っ端から当てはめました。インターフェースを切って、ファクトリを作って、ストラテジーにして、デコレータで包みました。 できたコードは、2週間後の自分に読めませんでした。

その一方で、本当に困っていた問題は解けていませんでした。 それはこれです。

テストが1行も書けない。

注文処理のテストを書こうとしたら、テストを走らせた瞬間にメールを送ろうとして落ちました。

error: 'connect ECONNREFUSED 127.0.0.1:25'

私は最初「テストの書き方が悪いのだろう」と思いました。モックのライブラリを調べました。 jest.mock を調べて、Node.js には無くて、proxyquire を調べて、どれも「読み込みを横取りする」道具でした。

違いました。問題はテストの側ではありませんでした。

placeOrder の中で new Mailer() をしていたから、外から差し替えようがなかった。 テストが書けないのは、腕の問題ではなく、設計の問題でした。

そして、その直し方には名前が付いていました。依存性注入(DI) です。 やることは1つだけ、「中で作る」のをやめて「引数で受け取る」 に変えるだけでした。フレームワークは1つも要りませんでした。

この記事は、23個のパターンを紹介する記事にしません。 それは調べれば出てきます。 この記事で確かめたいのは、たった1つのことです。

パターンは、困ってから当てる薬。先に飲むと毒。

だから、先に「困った」を作ります。 テストが書けなくて詰まるところを実際に見せて、それから直します。 そして最後に、やりすぎたコードを本当に書いて、素朴な版と行数で比べます。


対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • テストが書けない一番よくある原因は「中で new している」こと。腕でもライブラリでもない
  • DI(依存性注入)は引数で渡すこと。それだけ。DIコンテナも @Injectable も要らない
  • GoFの23個のうち、個人開発で本当に出るのは5つくらい。残りは「出会ってから調べる」でよい
  • JavaScript ではモジュール自体がシングルトン。クラスで書く必要はほぼ無く、そしてテストで必ず困る
  • if (logger) のような「あるか無いか」の分岐は、何もしない実体を渡せば消える(Null Object)
  • 種類が増えるたびにクラスを作るのをやめると、種類の追加がコードの追加でなくなる(Type Object)
  • パターンは行数を減らさない。増やす。 減るのは「変更するとき触る場所の数」だけ
  • 同じ変更を3回したときに、初めてパターンを検討する(Rule of Three)
  • レイヤード / MVC / ヘキサゴナル / イベント駆動 / マイクロサービスは、全部同じことの言い換え

この記事でやること

  1. メールを直接送る注文処理を書き、テストを走らせて ECONNREFUSED で落とす
  2. 引数で受け取る形に直し、偽のメーラーを渡したテストが node --test で通るところまで持っていく
  3. ストラテジー・アダプター・ファクトリ・オブザーバ・デコレータを、Before / After のコードで動かす
  4. モジュールがシングルトンであることを確かめ、テストの状態が次のテストへ持ち越されるところを再現する
  5. Null Object と Type Object を実装し、if とクラスが消えることを数で見る
  6. 「2つの数を足す」だけの処理にパターンを4つ重ね、素朴な1行版と行数・ファイル数で比べる

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
デザインパターンよくある設計上の困りごとと、その解き方に付いた名前。道具ではなく語彙
GoFGang of Four。1994年の本『Design Patterns』の著者4人。23個のパターンを整理した
依存(依存関係)あるコードが動くために必要としている別のもの。メーラー・DB・時計・乱数など
依存性注入(DI)依存を中で作らず、外から渡すこと。引数で渡せばそれがDI
テストダブル本物の代わりにテストで使う偽物の総称。スタブ(決まった値を返す)/スパイ(呼ばれ方を記録する)/モック(呼ばれ方を検証する)
副作用計算以外にやってしまうこと。メール送信・ファイル書き込み・時刻取得など
高階関数関数を受け取る、または関数を返す関数。JavaScriptのデコレータはこれで書く
YAGNIYou Aren’t Gonna Need It。「どうせ要らない」。先回りして作らない、という戒め
Rule of Three同じことを3回書いたときに初めて共通化する、という経験則
ポート/アダプタアプリが決めた形(ポート)と、外部をその形に変換する薄い層(アダプタ)

① 症状から入る — テストが書けない

先に、困った状態を作ります。

bash
$ mkdir -p ~/cslab/pattern
$ cd ~/cslab/pattern
$ node -v
v22.14.0

まず1つだけ設定ファイルを作ります。 これを置かないと、import を書いたときに警告が出ます。

bash
$ echo '{ "type": "module" }' > package.json

メール送信の部品

この記事では、外に一通もメールを送りません。 本物の SMTP には繋ぎません。 「繋ごうとした」ところだけを、標準出力に出して再現します。

bash
$ cat > mailer.js <<'EOF'
  // 本物のメール送信のつもりの部品。
  // ⚠️ この記事では外に一通も送らない。SMTPに繋がった「ふり」をして標準出力に出すだけ。
  export class Mailer {
    constructor() {
      this.host = process.env.SMTP_HOST;
      if (!this.host) {
        throw new Error('connect ECONNREFUSED 127.0.0.1:25');
      }
      console.log(`[Mailer] ${this.host} に接続しました`);
    }
    send(to, subject) {
      console.log(`[Mailer] 送信しました to=${to} subject=${subject}`);
      return { ok: true, to };
    }
  }
  EOF

SMTP_HOST という環境変数が無ければエラーになります。 これは意地悪ではなく、本物と同じ挙動です。 手元のVMには SMTP サーバーが動いていないので、 本物のメール送信ライブラリを使っても、まったく同じ ECONNREFUSED が出ます。

注文処理(よくある書き方)

bash
$ cat > order-bad.js <<'EOF'
  import { Mailer } from './mailer.js';
  
  export function placeOrder(order) {
    if (order.items.length === 0) throw new Error('商品がありません');
    const total = order.items.reduce((s, i) => s + i.price * i.qty, 0);
  
    const mailer = new Mailer();            // ← 中で作っている
    mailer.send(order.email, '注文を受け付けました', `合計 ${total} 円`);
  
    return { id: 'A-1001', total };
  }
  EOF

このコードは動きます。 そして普通です。 私も何年もこう書いていました。

テストを書こうとする

やりたいのは「合計金額の計算が正しいか」を確かめることだけです。 メールは関係ありません。

bash
$ cat > order-bad.test.js <<'EOF'
  import test from 'node:test';
  import assert from 'node:assert/strict';
  import { placeOrder } from './order-bad.js';
  
  test('合計金額が正しい', () => {
    const r = placeOrder({
      email: 'kokyaku@example.com',
      items: [{ price: 1200, qty: 2 }, { price: 500, qty: 1 }],
    });
    assert.equal(r.total, 2900);
  });
  EOF

$ node --test
TAP version 13
# Subtest: 合計金額が正しい
not ok 1 - 合計金額が正しい
  ---
  duration_ms: 2.3642
  failureType: 'testCodeFailure'
  error: 'connect ECONNREFUSED 127.0.0.1:25'
  code: 'ERR_TEST_FAILURE'
  stack: |-
    new Mailer (file:///home/user/cslab/pattern/mailer.js:7:13)
    placeOrder (file:///home/user/cslab/pattern/order-bad.js:7:18)
    TestContext.<anonymous> (file:///home/user/cslab/pattern/order-bad.test.js:6:13)
  ...
1..1
# tests 1
# pass 0
# fail 1

📸 スクリーンショット1: node --test が connect ECONNREFUSED 127.0.0.1:25 で落ちている出力。 fail 1 の行まで入れて残す

計算のテストを書いたのに、ネットワークのエラーで落ちました。

ここが今日の一番大事なところです。 私はこの状態で、長いこと「テストを書くのが難しい」と思っていました。難しかったのはテストではありません。

環境変数を入れれば通る、が

「じゃあ SMTP_HOST を入れれば通るのでは」と思います。通ります。

bash
$ SMTP_HOST=smtp.example.com node --test
TAP version 13
# [Mailer] smtp.example.com に接続しました
# [Mailer] 送信しました to=kokyaku@example.com subject=注文を受け付けました
# Subtest: 合計金額が正しい
ok 1 - 合計金額が正しい
1..1
# tests 1
# pass 1
# fail 0

通りました。そして、メールを送っています。

これが一番まずい形です。 落ちてくれるうちはまだ気付けます。 「通るけれど、テストを走らせるたびに kokyaku@example.com へメールが飛ぶ」 状態は、気付けません。 CI で1日100回テストが走ったら、顧客に100通届きます。

(この記事の Mailer は標準出力に出すだけなので、実際には一通も飛びません。ですが本物ではこうなります。)

何が悪かったのか

const mailer = new Mailer();   // ← ここ1行

placeOrder は、「メールを送る」ことだけでなく「どのメーラーを使うか」まで決めています。 使う側には、それを変える手段が1つもありません。

中で new すると、外から差し替えられない。 差し替えられないものは、テストできない。

テストしにくいコードは、たいてい変更もしにくいコードです。 「本番だけ別のメール業者にしたい」「開発中は送りたくない」——どれも、この1行のせいでできません。


② 依存性注入(DI)で直す — 引数で渡すだけ

直します。変えるのは1箇所だけです。

bash
$ cat > order.js <<'EOF'
  // 変えたのは「引数で受け取る」ようにしたところだけ。
  export function placeOrder(order, deps) {
    if (order.items.length === 0) throw new Error('商品がありません');
    const total = order.items.reduce((s, i) => s + i.price * i.qty, 0);
  
    deps.mailer.send(order.email, '注文を受け付けました', `合計 ${total} 円`);
  
    return { id: 'A-1001', total };
  }
  EOF

import { Mailer } が消えて、引数が1つ増えました。それだけです。

これが依存性注入(Dependency Injection)です。 注入という言葉のせいで難しそうに見えますが、「引数で渡す」以上のことは何もしていません。 Spring も NestJS も @Injectable も、この記事では一度も出てきません。要らないからです。

偽のメーラーを渡してテストする

bash
$ cat > order.test.js <<'EOF'
  import test from 'node:test';
  import assert from 'node:assert/strict';
  import { placeOrder } from './order.js';
  
  // 偽のメーラー。送らずに、送られた内容を配列に貯めるだけ。
  function fakeMailer() {
    const sent = [];
    return { sent, send: (to, subject, body) => { sent.push({ to, subject, body }); } };
  }
  
  test('合計金額が正しい', () => {
    const mailer = fakeMailer();
    const r = placeOrder(
      { email: 'kokyaku@example.com', items: [{ price: 1200, qty: 2 }, { price: 500, qty: 1 }] },
      { mailer }
    );
    assert.equal(r.total, 2900);
  });
  
  test('確認メールを1通だけ送る', () => {
    const mailer = fakeMailer();
    placeOrder({ email: 'a@example.com', items: [{ price: 100, qty: 1 }] }, { mailer });
    assert.equal(mailer.sent.length, 1);
    assert.equal(mailer.sent[0].to, 'a@example.com');
    assert.match(mailer.sent[0].body, /100 円/);
  });
  
  test('商品ゼロならメールを送らない', () => {
    const mailer = fakeMailer();
    assert.throws(() => placeOrder({ email: 'a@example.com', items: [] }, { mailer }));
    assert.equal(mailer.sent.length, 0);
  });
  EOF

$ node --test order.test.js
TAP version 13
# Subtest: 合計金額が正しい
ok 1 - 合計金額が正しい
# Subtest: 確認メールを1通だけ送る
ok 2 - 確認メールを1通だけ送る
# Subtest: 商品ゼロならメールを送らない
ok 3 - 商品ゼロならメールを送らない
1..3
# tests 3
# pass 3
# fail 0

3本通りました。1通も送っていません。

注目してほしいのは、増えたテストのほうです。

さっきは「合計が正しいか」しか書けませんでした。いまはこう書けます。

  • メールを1通だけ送っているか(2通送るバグが検出できる)
  • 商品ゼロのときは送っていないか(エラーなのに送ってしまうバグが検出できる)

DIが与えてくれたのは「テストが通ること」ではありません。 「送ったかどうかを確かめられること」です。 これは本物のメーラーでは絶対にできません。

この fakeMailer は、呼ばれ方を記録するので「スパイ」 と呼ばれます。 決まった値を返すだけなら「スタブ」、呼ばれ方の検証まで自分でやるなら「モック」です。 名前は後から知れば十分で、やることは「配列に貯める」だけです。

本番ではどう繋ぐのか

「じゃあ本番では誰が new Mailer() するのか」——入口で1回だけです。

// server.js(アプリの入口)
import { Mailer } from './mailer.js';
import { placeOrder } from './order.js';

const deps = { mailer: new Mailer() };   // ここ1箇所だけが本物を知っている

app.post('/orders', (req, res) => {
  res.json(placeOrder(req.body, deps));
});

DIは「new を無くす」ことではありません。「new する場所を、入口の1箇所に集める」ことです。 この「入口」を 合成ルート(Composition Root) と呼びます。名前は覚えなくてよいです。

APIの入口そのものについては、本線の APIの正体はJSONを返すHTTP — Node.jsで作る にあります。

DIコンテナは要るのか

個人開発では、要りません。

やり方書く量いつ使うか
引数で渡す0まずこれ。ほぼ全部これで足りる
デフォルト引数で本物を入れておく0呼び出し側が多く、毎回渡すのが面倒なとき
ファクトリ関数(③のファクトリ)10行依存が5個以上になり、組み合わせが環境で変わるとき
DIコンテナ(InversifyJS 等)ライブラリ依存が数十個ある大規模なアプリ

依存が3個のアプリにコンテナを入れると、「何が渡っているか」がコードから消えます。 引数なら、関数の1行目を見れば全部書いてあります。


③ 実際に効く5つだけ、コードで

GoFの23個を並べません。 個人開発で本当に出会った5つだけをやります。

それぞれ Before / After を並べます。短くならないものは、短くならないと書きます。

ストラテジー — if の連鎖を、名前と関数の表にする

Before。支払い方法ごとの手数料です。

bash
$ cat > strategy-before.js <<'EOF'
  function fee(method, amount) {
    if (method === 'credit') {
      return Math.round(amount * 0.036);
    } else if (method === 'konbini') {
      return 190;
    } else if (method === 'bank') {
      return amount >= 30000 ? 660 : 440;
    } else if (method === 'paypay') {
      return Math.round(amount * 0.0195);
    } else {
      throw new Error('未対応の支払い方法: ' + method);
    }
  }
  for (const m of ['credit', 'konbini', 'bank', 'paypay']) {
    console.log(m, fee(m, 30000));
  }
  EOF
$ node strategy-before.js
credit 1080
konbini 190
bank 660
paypay 585

After。

bash
$ cat > strategy-after.js <<'EOF'
  // 「if の連鎖」を「名前 → 関数」の表に置き換えただけ。
  const FEES = {
    credit:  (a) => Math.round(a * 0.036),
    konbini: () => 190,
    bank:    (a) => (a >= 30000 ? 660 : 440),
    paypay:  (a) => Math.round(a * 0.0195),
  };
  
  export function fee(method, amount) {
    const f = FEES[method];
    if (!f) throw new Error('未対応の支払い方法: ' + method);
    return f(amount);
  }
  EOF

同じ結果になります。 行数はほとんど変わりません。変わったのは3つです。

  1. 「対応している方法の一覧」が Object.keys(FEES) で取れる。 if の連鎖からは取れません
  2. 1つ足すのに FEES に1行足すだけ。 else if を正しい位置に入れる必要がない
  3. テストが「全部の方法を回す」形で書ける

3つ目を実際にやります。

bash
$ cat > strategy.test.js <<'EOF'
  import test from 'node:test';
  import assert from 'node:assert/strict';
  import { fee } from './strategy-after.js';
  
  test('表に載っている方法はすべて数値を返す', () => {
    for (const m of ['credit', 'konbini', 'bank', 'paypay']) {
      assert.equal(typeof fee(m, 10000), 'number');
    }
  });
  test('知らない方法は例外', () => {
    assert.throws(() => fee('bitcoin', 100), /未対応/);
  });
  EOF
$ node --test strategy.test.js
# Subtest: 表に載っている方法はすべて数値を返す
ok 1 - 表に載っている方法はすべて数値を返す
# Subtest: 知らない方法は例外
ok 2 - 知らない方法は例外
1..2
# tests 2
# pass 2
# fail 0

GoFのストラテジーは「クラスを作ってインターフェースを実装する」形で説明されます。 JavaScript では関数がそのまま値なので、オブジェクト1つで足ります。 言語が持っている機能でできることに、わざわざクラスを5個作らないでください。

ただし、いつでもこうすべきではありません。 分岐が2つしかないなら if のほうが読めます。 この形が効くのは、「一覧が欲しくなったとき」と「増え続けると分かったとき」です。

アダプター — 外部が変わっても中を守る

「SMS送信ライブラリを乗り換えたい。でもアプリ側は触りたくない」 という場面です。

bash
$ cat > adapter.js <<'EOF'
  // 外部ライブラリA(今使っているもの)
  const legacySms = {
    postMessage(opts) {           // 引数が独特
      return { status: 200, id: 'legacy-' + opts.number };
    },
  };
  // 外部ライブラリB(乗り換え先)。引数も戻り値も違う
  const newSms = {
    send(to, text) {
      return { code: 'OK', messageId: 'new-' + to };
    },
  };
  
  // 自分のアプリが使う「形」を1つ決める(ポート)
  // send(to, body) -> { ok: boolean, id: string }
  
  const legacyAdapter = {
    send: (to, body) => {
      const r = legacySms.postMessage({ number: to, content: body });
      return { ok: r.status === 200, id: r.id };
    },
  };
  const newAdapter = {
    send: (to, body) => {
      const r = newSms.send(to, body);
      return { ok: r.code === 'OK', id: r.messageId };
    },
  };
  
  // アプリ側のコードは1行も変わらない
  function notify(sms, user) {
    const r = sms.send(user.tel, '注文を受け付けました');
    console.log(`通知 ok=${r.ok} id=${r.id}`);
  }
  
  const user = { tel: '09000000000' };
  notify(legacyAdapter, user);
  notify(newAdapter, user);
  EOF
$ node adapter.js
通知 ok=true id=legacy-09000000000
通知 ok=true id=new-09000000000

notify は1行も変わっていません。 乗り換えで書き換えたのはアダプタ2つだけです。

ここでのポイントは「アダプタを書いたこと」ではありません。 「自分のアプリが使う形(send(to, body) -> { ok, id })を、先に自分で決めたこと」 です。 外部の形をそのままアプリ中に広げていたら、乗り換えのときに全部の呼び出し箇所を直すことになります。

そして、After のほうが行数は増えています。 減っていません。 減ったのは「乗り換えるときに触るファイルの数」だけです。 これがパターンの正体です。

アダプターを最初から全部の外部ライブラリに被せないでください。 乗り換える気配が無いものにアダプタを書くのは、ただの余分な1層です。 JSON.parse にアダプタは要りません。

ファクトリ — 作り方を1箇所に集める

bash
$ cat > factory.js <<'EOF'
  // Before: 使う側が毎回「作り方」を知っている
  function handlerBefore(env) {
    const mailer = env === 'test'
      ? { send: () => {} }
      : { send: (to) => console.log('送信 ' + to) };
    const clock = env === 'test' ? () => new Date('2026-01-01') : () => new Date();
    const log = env === 'prod' ? console.log : () => {};
    return { mailer, clock, log };
  }
  
  // After: 作り方を1箇所に集める
  export function createDeps(env = process.env.NODE_ENV ?? 'dev') {
    const base = {
      mailer: { send: (to) => console.log('[mail] ' + to) },
      clock: () => new Date(),
      log: console.log,
    };
    const overrides = {
      test: { mailer: { send: () => {} }, clock: () => new Date('2026-01-01T00:00:00Z'), log: () => {} },
      dev:  { log: (...a) => console.log('[dev]', ...a) },
      prod: {},
    };
    return { ...base, ...(overrides[env] ?? {}) };
  }
  
  for (const env of ['dev', 'test', 'prod']) {
    const d = createDeps(env);
    console.log(env, '->', d.clock().toISOString());
  }
  EOF
$ node factory.js
dev -> 2026-09-04T01:20:40.397Z
test -> 2026-01-01T00:00:00.000Z
prod -> 2026-09-04T01:20:40.402Z

test のときだけ時計が固定されているのが分かります。 時計は依存です。 new Date() を関数の中で直接呼ぶと、「1月1日に実行したときだけ落ちるバグ」 のテストが書けません。

ファクトリは「作り方の置き場所」です。 ②の合成ルートと同じものを、関数の形にしただけです。 new を隠すために作るのではありません。 隠したいなら②のように引数で渡せば済みます。

オブザーバ — Node.js の EventEmitter がまさにこれ

Before は「注文処理が、後でやることを全部知っている」形です。

bash
$ cat > observer.js <<'EOF'
  import { EventEmitter } from 'node:events';
  
  // Before: 注文処理が「後でやること」を全部知っている
  function placeOrderBefore(order) {
    const total = 2900;
    sendMail(order); sendSlack(order); writeAuditLog(order); updateStats(order);
    return total;
  }
  function sendMail(o) { console.log('  mail'); }
  function sendSlack(o) { console.log('  slack'); }
  function writeAuditLog(o) { console.log('  audit'); }
  function updateStats(o) { console.log('  stats'); }
  
  // After: 「注文が確定した」とだけ言う
  class OrderService extends EventEmitter {
    place(order) {
      const total = order.items.reduce((s, i) => s + i.price * i.qty, 0);
      this.emit('placed', { id: 'A-1001', total, email: order.email });
      return total;
    }
  }
  
  const svc = new OrderService();
  svc.on('placed', (o) => console.log('  [mail]  ', o.email, o.total));
  svc.on('placed', (o) => console.log('  [slack] ', o.id));
  svc.on('placed', (o) => console.log('  [audit] ', JSON.stringify(o)));
  
  console.log('Before:'); placeOrderBefore({ email: 'a@example.com' });
  console.log('After:');
  svc.place({ email: 'a@example.com', items: [{ price: 1200, qty: 2 }, { price: 500, qty: 1 }] });
  
  console.log('登録数:', svc.listenerCount('placed'));
  
  // 購読者が例外を投げるとどうなるか
  svc.on('placed', () => { throw new Error('Slack API が落ちている'); });
  try {
    svc.place({ email: 'b@example.com', items: [{ price: 100, qty: 1 }] });
  } catch (e) {
    console.log('⚠️ 注文処理まで巻き添えで落ちた:', e.message);
  }
  EOF
$ node observer.js
Before:
  mail
  slack
  audit
  stats
After:
  [mail]   a@example.com 2900
  [slack]  A-1001
  [audit]  {"id":"A-1001","total":2900,"email":"a@example.com"}
登録数: 3
  [mail]   b@example.com 100
  [slack]  A-1001
  [audit]  {"id":"A-1001","total":100,"email":"b@example.com"}
⚠️ 注文処理まで巻き添えで落ちた: Slack API が落ちている

EventEmitter は Node.js に最初から入っています。オブザーバパターンの実装そのものです。 ライブラリを探さないでください。 import { EventEmitter } from 'node:events' で終わりです。

そして最後の3行が大事です。

購読者が例外を投げると、emit を呼んだ側まで落ちます。 emit は同期的に、登録順で全部呼ぶだけだからです。別スレッドでも、非同期でもありません。

「Slack が落ちていたら注文も失敗する」 ——これは分離できていません。

svc.on('placed', (o) => {
  try { sendSlack(o); } catch (e) { console.error('slack失敗(注文は成功扱い)', e.message); }
});

オブザーバで分離できるのは「知識」であって「障害」ではありません。 障害まで分けたいなら、購読者側で必ず捕まえるか、本物のキューに出す必要があります。 そこは 機能を足すたび注文APIが壊れる — システム設計深掘り にあります。

オブザーバのもう1つの代償は「追えなくなること」です。 emit('placed') を見ても、誰が反応するかはコードに書いてありません。 grep 'placed' して探すことになります。 購読者が3つなら得ですが、2つなら普通に関数を呼んだほうが読めます。

デコレータ — 元の関数を書き換えずに、ログ・リトライ・キャッシュを足す

JavaScript では、高階関数で書きます。 クラスも @ も要りません。

bash
$ cat > decorator.js <<'EOF'
  // 元の関数。3回に2回失敗するAPI呼び出しのつもり
  let calls = 0;
  async function fetchPrice(id) {
    calls++;
    if (calls % 3 !== 0) throw new Error('ETIMEDOUT');
    return { id, price: 1200 };
  }
  
  // ── デコレータ3つ。どれも「関数を受け取って関数を返す」だけ ──
  const withLog = (fn) => async (...args) => {
    const t = Date.now();
    try {
      const r = await fn(...args);
      console.log(`  [log] ${fn.name}(${args}) ok ${Date.now() - t}ms`);
      return r;
    } catch (e) {
      console.log(`  [log] ${fn.name}(${args}) NG ${e.message}`);
      throw e;
    }
  };
  
  const withRetry = (fn, times = 3, waitMs = 10) => async (...args) => {
    let last;
    for (let i = 1; i <= times; i++) {
      try { return await fn(...args); }
      catch (e) { last = e; console.log(`  [retry] ${i}回目失敗`); await new Promise(r => setTimeout(r, waitMs)); }
    }
    throw last;
  };
  
  const withCache = (fn) => {
    const store = new Map();
    return async (...args) => {
      const key = JSON.stringify(args);
      if (store.has(key)) { console.log('  [cache] hit', key); return store.get(key); }
      const r = await fn(...args);
      store.set(key, r);
      return r;
    };
  };
  
  // 元の fetchPrice は1文字も書き換えていない
  const getPrice = withCache(withLog(withRetry(fetchPrice)));
  
  console.log('1回目:', await getPrice(7));
  console.log('2回目:', await getPrice(7));
  console.log('別のID:', await getPrice(9));
  EOF
$ node decorator.js
  [retry] 1回目失敗
  [retry] 2回目失敗
  [log] (7) ok 38ms
1回目: { id: 7, price: 1200 }
  [cache] hit [7]
2回目: { id: 7, price: 1200 }
  [retry] 1回目失敗
  [retry] 2回目失敗
  [log] (9) ok 30ms
別のID: { id: 9, price: 1200 }

fetchPrice は1文字も変えていません。 それでもリトライし、ログを出し、キャッシュしています。

そして、包む順番で意味が変わります。

withCache(withLog(withRetry(fetchPrice)))   // キャッシュが一番外
withRetry(withCache(withLog(fetchPrice)))   // リトライが一番外
並び何が起きるか
キャッシュが外2回目はログもリトライも動かない(上の出力の [cache] hit のとき、ログが出ていない)
リトライが外リトライのたびにキャッシュを見に行く。失敗はキャッシュされないので毎回本体を叩く

上の出力をもう一度見てください。 2回目: の行の直前に [log] がありません。キャッシュが外側だからです。

デコレータを重ねるときは、順番を必ず声に出して確認してください。 私は「リトライのログが出ない」と言って30分潰しました。出ないのが正しい動きでした。

リトライそのものが危険な場面もあります。 落ちている相手に全員でリトライすると、復旧をさらに遅らせます。 そこは 落ちても全部は止めない — サーキットブレーカと縮退 にあります。

5つのまとめ

パターン困りごとJavaScriptでの実体After は短くなるか
ストラテジーif の連鎖が伸び続けるオブジェクト1つ(名前→関数)ほぼ同じ。一覧が取れるのが利点
アダプター外部の形が中に染み出す薄い関数1つ増える。乗り換え時の変更点が減る
ファクトリ作り方が散らばる関数1つ増える。環境差が1箇所に集まる
オブザーバ処理が後続を全部知っているEventEmitter増える。追いにくくもなる
デコレータログ・リトライを全関数に書く高階関数本体は変わらない。横の関心事が外に出る

5つのうち4つで、行数は増えています。 これは失敗ではありません。 パターンが減らすのは行数ではなく、「変更のときに触る場所の数」だけです。


④ シングルトンの扱い — JavaScript では書く必要がほぼ無い

GoFで一番有名なのがシングルトンです。そして、一番使い方を間違えられているものでもあります。

JavaScript ではモジュールがそもそもシングルトン

bash
$ cat > config.js <<'EOF'
  // ⚠️ クラスで Singleton を書いていない。モジュールが1回しか評価されないだけ。
  console.log('[config.js] 評価されました');
  export const config = { retry: 3, apiBase: 'https://example.com' };
  export const counter = { hits: 0 };
  EOF

$ cat > singleton-check.js <<'EOF'
  import { config as a } from './config.js';
  import { config as b } from './config.js';
  const { config: c } = await import('./config.js');
  console.log('同じ実体か:', a === b, a === c);
  a.retry = 99;
  console.log('片方を書き換えると:', b.retry);
  EOF
$ node singleton-check.js
[config.js] 評価されました
同じ実体か: true true
片方を書き換えると: 99

3回 import しても、[config.js] 評価されました は1回しか出ません。 a === b === c で、片方を書き換えると全部変わります。

ES Modules は、一度読み込んだモジュールを記録しておいて使い回します。 つまり、export したオブジェクトは最初からシングルトンです。

class Config { static #instance ... } を書く必要はありません。 それはモジュールを持たない言語のための工夫です。

そして、テストで必ず困る

シングルトンの本当の問題は「1個であること」ではなく「消せないこと」です。

bash
$ cat > singleton.test.js <<'EOF'
  import test from 'node:test';
  import assert from 'node:assert/strict';
  import { counter } from './config.js';
  
  test('A: 1回叩いたら1になる', () => {
    counter.hits++;
    assert.equal(counter.hits, 1);
  });
  test('B: これも1回叩いたら1のはず', () => {
    counter.hits++;
    assert.equal(counter.hits, 1);   // ← 落ちる
  });
  EOF
$ node --test singleton.test.js
TAP version 13
# [config.js] 評価されました
# Subtest: A: 1回叩いたら1になる
ok 1 - A: 1回叩いたら1になる
# Subtest: B: これも1回叩いたら1のはず
not ok 2 - B: これも1回叩いたら1のはず
  ---
  failureType: 'testCodeFailure'
  error: |-
    Expected values to be strictly equal:

    2 !== 1

  code: 'ERR_ASSERTION'
  expected: 1
  actual: 2
  ...
1..2
# tests 2
# pass 1
# fail 1

📸 スクリーンショット2: singleton.test.js の実行結果。2 !== 1 と expected: 1 / actual: 2 が写っていること

B は単独で走らせれば通ります。A の後だと落ちます。

これが「テストの順番を変えたら落ちるようになった」の正体です。 私は昔これを「テストランナーのバグ」だと思っていました。バグではなく、状態を共有していただけでした。

どう扱うか

対象シングルトンでよいか
読むだけの設定(config.apiBase)よい。書き換えないなら共有で困らない
DBのコネクションプールよい。むしろ1個であるべき(②のように引数で渡す)
書き換わるカウンタ・キャッシュ・ログイン中のユーザーだめ。上のように必ずテストが壊れる

直し方は②と同じです。「モジュールから取る」のをやめて「引数で受け取る」ようにします。

// 悪い: モジュールから直接取る
import { counter } from './config.js';
export function hit() { counter.hits++; }

// よい: 外から受け取る
export function hit(counter) { counter.hits++; }

テストごとに { hits: 0 } を新しく作れば、順番に依存しなくなります。


⑤ Null Object — if (logger) を書かなくて済む

「ロガーは渡されるかもしれないし、渡されないかもしれない」 という状況です。

bash
$ cat > nullobject.js <<'EOF'
  // Before: logger があるかどうかを、使う側が毎回気にする
  function importBefore(rows, logger) {
    if (logger) logger.info('開始 ' + rows.length + '件');
    let ok = 0;
    for (const r of rows) {
      if (!r.name) { if (logger) logger.warn('name が無い行を飛ばした'); continue; }
      ok++;
    }
    if (logger) logger.info('完了 ' + ok + '件');
    return ok;
  }
  
  // 何もしないロガー(Null Object)
  const nullLogger = { info() {}, warn() {}, error() {} };
  
  // After: if が全部消える
  function importAfter(rows, logger = nullLogger) {
    logger.info('開始 ' + rows.length + '件');
    let ok = 0;
    for (const r of rows) {
      if (!r.name) { logger.warn('name が無い行を飛ばした'); continue; }
      ok++;
    }
    logger.info('完了 ' + ok + '件');
    return ok;
  }
  
  const rows = [{ name: 'a' }, {}, { name: 'c' }];
  const realLogger = { info: (m) => console.log('  INFO ' + m), warn: (m) => console.log('  WARN ' + m), error: console.error };
  
  console.log('Before(logger あり):'); importBefore(rows, realLogger);
  console.log('Before(logger なし):'); importBefore(rows, undefined);
  console.log('After(logger あり):'); importAfter(rows, realLogger);
  console.log('After(logger なし):', importAfter(rows), '件');
  EOF
$ node nullobject.js
Before(logger あり):
  INFO 開始 3件
  WARN name が無い行を飛ばした
  INFO 完了 2件
Before(logger なし):
After(logger あり):
  INFO 開始 3件
  WARN name が無い行を飛ばした
  INFO 完了 2件
After(logger なし): 2 件

if の数を数えます。

bash
$ grep -c "if (logger)" nullobject.js
3

Before には if (logger) が3つ、After には0です。 そして「何もしないロガー」は1行です。

const nullLogger = { info() {}, warn() {}, error() {} };

これが Null Object です。「無い」を null で表すのをやめて、「何もしない実体」で表します。 null チェックは使う側全員の仕事ですが、何もしない実体を渡せば誰の仕事でもなくなります。

他にもこう使えます。

場所Null Object
メール送信(開発中は送らない){ send() {} }
キャッシュ(無効化したい){ get: () => undefined, set() {} }
権限チェック(開発中は全部通す){ can: () => true }
通知(テスト時)②で書いた fakeMailer() もこれの仲間

注意が1つあります。 エラーまで黙らせないでください。

const nullLogger = { info() {}, warn() {}, error() {} };   // error まで捨てている

error を捨てると、「例外は出ているのにログに何も出ない」 という一番調べにくい状態になります。 私はこれで2時間潰しました。 error だけは console.error にしておくのが安全です。

const nullLogger = { info() {}, warn() {}, error: console.error };

⑥ Type Object — 種類ごとにクラスを作るのをやめる

ゲームの敵キャラを例にします。「種類が増えるたびにクラスを作る」形から始めます。

bash
$ cat > typeobject-before.js <<'EOF'
  class Enemy {
    constructor(name, hp, atk) { this.name = name; this.hp = hp; this.atk = atk; }
    attack() { return `${this.name} の攻撃 ${this.atk} ダメージ`; }
  }
  class Slime extends Enemy   { constructor() { super('スライム', 10, 3); } }
  class Goblin extends Enemy  { constructor() { super('ゴブリン', 25, 7); } }
  class Wolf extends Enemy    { constructor() { super('ウルフ', 30, 9); } }
  class Dragon extends Enemy  { constructor() { super('ドラゴン', 300, 45); } }
  class Skeleton extends Enemy{ constructor() { super('スケルトン', 40, 12); } }
  
  for (const E of [Slime, Goblin, Wolf, Dragon, Skeleton]) {
    console.log(new E().attack());
  }
  EOF
$ node typeobject-before.js
スライム の攻撃 3 ダメージ
ゴブリン の攻撃 7 ダメージ
ウルフ の攻撃 9 ダメージ
ドラゴン の攻撃 45 ダメージ
スケルトン の攻撃 12 ダメージ

動きます。そして、これが「クラス爆発」です。

Slime と Goblin の違いは、数字3つだけです。振る舞いは1つも違いません。 それなのにクラスが5個あります。 敵が100種類なら、クラスが100個できます。

データで持つ

bash
$ cat > enemies.json <<'EOF'
  {
    "slime":    { "name": "スライム",   "hp": 10,  "atk": 3  },
    "goblin":   { "name": "ゴブリン",   "hp": 25,  "atk": 7  },
    "wolf":     { "name": "ウルフ",     "hp": 30,  "atk": 9  },
    "dragon":   { "name": "ドラゴン",   "hp": 300, "atk": 45 },
    "skeleton": { "name": "スケルトン", "hp": 40,  "atk": 12 }
  }
  EOF

$ cat > typeobject-after.js <<'EOF'
  import { readFile } from 'node:fs/promises';
  const TYPES = JSON.parse(await readFile(new URL('./enemies.json', import.meta.url), 'utf8'));
  
  class Enemy {
    constructor(typeId) {
      this.type = TYPES[typeId];
      if (!this.type) throw new Error('知らない種類: ' + typeId);
      this.hp = this.type.hp;
    }
    attack() { return `${this.type.name} の攻撃 ${this.type.atk} ダメージ`; }
  }
  
  for (const id of Object.keys(TYPES)) console.log(new Enemy(id).attack());
  console.log('クラスの数:', 1, '/ 種類の数:', Object.keys(TYPES).length);
  EOF
$ node typeobject-after.js
スライム の攻撃 3 ダメージ
ゴブリン の攻撃 7 ダメージ
ウルフ の攻撃 9 ダメージ
ドラゴン の攻撃 45 ダメージ
スケルトン の攻撃 12 ダメージ
クラスの数: 1 / 種類の数: 5

ここからが本題です。敵を1種類増やします。

bash
$ node -e "
  const fs=require('fs');
  const j=JSON.parse(fs.readFileSync('enemies.json','utf8'));
  j.mimic={name:'ミミック',hp:80,atk:22};
  fs.writeFileSync('enemies.json', JSON.stringify(j,null,2));
  "
$ node typeobject-after.js
スライム の攻撃 3 ダメージ
ゴブリン の攻撃 7 ダメージ
ウルフ の攻撃 9 ダメージ
ドラゴン の攻撃 45 ダメージ
スケルトン の攻撃 12 ダメージ
ミミック の攻撃 22 ダメージ
クラスの数: 1 / 種類の数: 6

JavaScript のコードは1文字も変えていません。 JSON に1件足しただけです。

行数を並べます。

bash
$ wc -l typeobject-before.js typeobject-after.js enemies.json
  13 typeobject-before.js
  14 typeobject-after.js
  31 enemies.json
  58 total

合計行数は増えています。 また増えました。でも増えた場所が違います。

種類を1つ足すには
Before(クラス)JavaScriptのファイルを編集して class を1つ書く。配列にも追加する
After(データ表)JSONに1件足すだけ。プログラムを触らない

この差が効いてくる場面は、はっきりしています。

  • 企画の人がバランス調整をする(プログラマを待たなくてよくなる)
  • 管理画面から追加できるようにしたい(DBの1行になるだけ)
  • A/Bテストで数字を差し替えたい(デプロイなしで変えられる)

ただし、Type Object が向かない場面もあります。

「振る舞い」が種類ごとに本当に違うなら、データでは持てません。 ドラゴンだけ「火を吐いて周囲3マスに当たる」なら、その挙動はコードです。

やり方は、③のストラテジーと組み合わせることです。 データに "skill": "fire_breath" と持たせ、SKILLS という関数の表を1つ用意します。 「数字はデータ、動きは表引き」 の形になります。


⑦ パターンを使わないほうがよい場面

ここまで「使うと得」の話をしました。ここから逆をやります。

お題は「2つの数を足す」です。 これに、③でやったパターンを全部かけます。 インターフェース → ファクトリ → ストラテジー → デコレータ、の順です。

素朴な版

bash
$ cat > naive.js <<'EOF'
  export const add = (a, b) => a + b;
  EOF

1行です。

やりすぎた版

bash
$ mkdir -p over

$ cat > over/operation.js <<'EOF'
  // 「インターフェース」のつもりの抽象基底クラス
  export class Operation {
    execute(a, b) { throw new Error('サブクラスで実装すること'); }
  }
  EOF

$ cat > over/add-operation.js <<'EOF'
  import { Operation } from './operation.js';
  export class AddOperation extends Operation {
    execute(a, b) { return a + b; }
  }
  EOF

$ cat > over/operation-factory.js <<'EOF'
  import { AddOperation } from './add-operation.js';
  export class OperationFactory {
    static create(kind) {
      switch (kind) {
        case 'add': return new AddOperation();
        default: throw new Error('未対応の演算: ' + kind);
      }
    }
  }
  EOF

$ cat > over/calculator-strategy.js <<'EOF'
  export class CalculatorStrategy {
    constructor(operation) { this.operation = operation; }
    calculate(a, b) { return this.operation.execute(a, b); }
  }
  EOF

$ cat > over/logging-decorator.js <<'EOF'
  export class LoggingDecorator {
    constructor(inner, logger) { this.inner = inner; this.logger = logger; }
    calculate(a, b) {
      this.logger.info(`calculate(${a}, ${b})`);
      const r = this.inner.calculate(a, b);
      this.logger.info(`=> ${r}`);
      return r;
    }
  }
  EOF

$ cat > over/index.js <<'EOF'
  import { OperationFactory } from './operation-factory.js';
  import { CalculatorStrategy } from './calculator-strategy.js';
  import { LoggingDecorator } from './logging-decorator.js';
  
  const nullLogger = { info() {}, warn() {}, error() {} };
  
  export function makeCalculator(kind = 'add', logger = nullLogger) {
    return new LoggingDecorator(
      new CalculatorStrategy(OperationFactory.create(kind)),
      logger
    );
  }
  EOF

動かします。

bash
$ cat > over-main.js <<'EOF'
  import { makeCalculator } from './over/index.js';
  import { add } from './naive.js';
  console.log('やりすぎ版:', makeCalculator().calculate(2, 3));
  console.log('素朴版:    ', add(2, 3));
  EOF
$ node over-main.js
やりすぎ版: 5
素朴版:     5

同じ答えです。 数えます。

bash
$ wc -l naive.js over/*.js
   1 naive.js
   4 over/add-operation.js
   4 over/calculator-strategy.js
  12 over/index.js
   9 over/logging-decorator.js
   9 over/operation-factory.js
   4 over/operation.js
  43 total
行数ファイル数2+3 を読むために開くファイル
素朴版1行1個1個
やりすぎ版42行6個6個(index → decorator → strategy → factory → add-operation → operation)

42倍です。 そして「2に3を足している」ことを確かめるのに、6ファイル開く必要があります。

「でも拡張しやすいのでは」を実測する

引き算を足してみます。両方に。

bash
$ # 素朴版
$ echo 'export const sub = (a, b) => a - b;' >> naive.js

$ # やりすぎ版
$ cat > over/sub-operation.js <<'EOF'
  import { Operation } from './operation.js';
  export class SubOperation extends Operation {
    execute(a, b) { return a - b; }
  }
  EOF

$ cat > over/operation-factory.js <<'EOF'
  import { AddOperation } from './add-operation.js';
  import { SubOperation } from './sub-operation.js';
  export class OperationFactory {
    static create(kind) {
      switch (kind) {
        case 'add': return new AddOperation();
        case 'sub': return new SubOperation();
        default: throw new Error('未対応の演算: ' + kind);
      }
    }
  }
  EOF

$ cat > over-main2.js <<'EOF'
  import { makeCalculator } from './over/index.js';
  import { add, sub } from './naive.js';
  console.log('やりすぎ版:', makeCalculator('add').calculate(10, 4), makeCalculator('sub').calculate(10, 4));
  console.log('素朴版:    ', add(10, 4), sub(10, 4));
  EOF
$ node over-main2.js
やりすぎ版: 14 6
素朴版:     14 6

「引き算を足す」ためにやったことを並べます。

新しく作ったファイル編集したファイル書いた行
素朴版0個1個(naive.js)1行
やりすぎ版1個(sub-operation.js)1個(operation-factory.js)6行

拡張性でも負けています。

「開放閉鎖の原則(追加には開き、修正には閉じる)」を守るために作った構造なのに、 結局 operation-factory.js を修正しています。 閉じていません。

bash
$ wc -l naive.js over/*.js | tail -1
  50 total

素朴版は2行、やりすぎ版は48行になりました。

では、いつパターンを入れるのか

結論はこれです。

同じ変更を3回以上したときに、初めてパターンを検討する。

「3回」は経験則で、Rule of Three と呼ばれます。 なぜ3回かというと、2回では形が見えないからです。

  • 1回目: そのまま書く
  • 2回目: 似ていることに気付く。まだ共通化しない(似て見えるだけかもしれない)
  • 3回目: 3つ並べると、何が同じで何が違うかが分かる。ここで初めて抜き出す

この記事の①②が良い例です。

いつ入れたか
DIテストが書けなくて詰まってから。 先回りしていない
ストラテジー支払い方法が4つに増え、else if を足すのが3回目になってから
やりすぎ版の構造何にも困っていないのに入れた。だから毒になった

私が実際に使っている判断の言葉はこれです。

「いま、何に困っているか、1文で言えるか?」

言えないなら入れません。「将来変わるかもしれないから」は1文になっていません。 「支払い方法を足すたびに3ファイル触るのが3回目だから」は1文になっています。

同じ話は共通化全般に当てはまります。 そのフックは共通化してはいけない — React深掘り にも書きました。

そして、パターンを消すのは足すより難しいです。 一度6ファイルに割ったものを1行に戻すのは、心理的にほぼ不可能です。 「せっかく作ったのに」が働きます。だから、入れないほうが安い。


⑧ アーキテクチャの型 — 全部「変わるものと変わらないものを分ける」

パターンの話をすると、次に必ずアーキテクチャの話が出ます。 名前だけ整理しておきます。

型何をどう分けるか個人開発での現実
レイヤード(3層)表示 / 業務ロジック / データ の3段に上下で分ける。上から下へだけ呼ぶまずこれで十分。ほぼ全部これでいい
MVCModel(データと規則)/ View(見た目)/ Controller(受付)レイヤードのWeb版。フレームワークが最初からこの形
ヘキサゴナル(ポートとアダプタ)中心に業務ロジック、外側に「外部との変換」。③のアダプターを全体でやる形DBやAPIを差し替える予定があるなら。無いなら過剰
イベント駆動「起きたこと」を流し、聞きたい人が反応する。③のオブザーバの全体版非同期にしたい処理が出てから。最初からは重い
マイクロサービスサービスごとにプロセスもDBも分ける一人では入れない。 分散システムの問題が全部降ってくる

5つとも、言っていることは同じです。 「変わりやすいもの(画面・外部API・DBの種類)」と「変わりにくいもの(業務の規則)」を分ける。

違うのは分ける単位だけです。 関数で分けるのがパターン、ファイルとフォルダで分けるのがレイヤード、 プロセスで分けるのがマイクロサービスです。

レイヤードを具体的に

この記事で書いたものを並べると、もうレイヤードになっています。

server.js            ← 表示・受付の層(HTTPを知っている)
order.js             ← 業務ロジックの層(HTTPもSMTPも知らない)
mailer.js            ← 外部との接続の層(SMTPを知っている)

order.js が mailer.js を import していないことが大事です。 ②で引数にしたおかげで、業務ロジックの層は、外の世界を1つも知りません。

これが「テストできる」の正体です。 そしてこれがヘキサゴナルの中心部そのものです。 名前を先に覚える必要はありませんでした。困って直したら、勝手にその形になりました。

マイクロサービスに行く前に

「将来マイクロサービスにするから、最初から分けておく」は、⑦のやりすぎ版と同じ失敗です。

プロセスを分けた瞬間に、次のものが全部降ってきます。

  • ネットワーク越しの呼び出しは失敗する(③のリトライとサーキットブレーカが必須になる)
  • トランザクションがサービスをまたげない(1つ失敗したときの戻し方を自分で書く)
  • ログが分散する(1リクエストを追うのに複数のサービスのログを突き合わせる)
  • デプロイの順番を考える必要が出る

1人で作っているうちは、この代償を払う理由がありません。 本線の まだマイクロサービスにしない — モノリスと12 Factor に、 そこの判断の話をまとめてあります。

📸 スクリーンショット3: wc -l naive.js over/*.js の出力。 1 naive.js と 43 total(引き算追加後なら 50 total)が同じ画面に写っていること


つまずいたところ

遠回りした順に書きます。

1. テストが落ちる原因を、テスト側だと思い込んだ

ECONNREFUSED が出たとき、最初にやったのはモックライブラリを探すことでした。 proxyquire、mock-require、esmock と順に調べて、どれも「import を横取りする」道具でした。

横取りが必要になっている時点で、設計が間違っています。 placeOrder(order, deps) に変えたら、ライブラリは1つも要りませんでした。

ライブラリを探し始めたら、一度手を止めて「そもそも差し替えられる形か」を見てください。

2. SMTP_HOST を設定して「解決した」ことにしかけた

エラーが消えたので直ったと思いました。 消えたのはエラーだけで、メールは送っていました。

テストが通ることと、テストが正しいことは別です。 「テストを走らせて何が起きるか」を、ok 1 の上の行まで読んでください。[Mailer] 送信しました が出ていました。

3. デコレータのログに関数名が出なかった

上の decorator.js の出力を見てください。

  [log] (7) ok 38ms

fetchPrice と出るはずが、空です。

理由は withLog が受け取っているのが fetchPrice ではなく、withRetry が返した無名のアロー関数だからです。 fn.name は空文字になります。

直すなら、名前を渡すか、Object.defineProperty で付け替えます。

const withRetry = (fn, times = 3) => {
  const wrapped = async (...args) => { /* ... 略 ... */ };
  Object.defineProperty(wrapped, 'name', { value: fn.name });
  return wrapped;
};

デコレータで包むと、名前・引数の数(fn.length)・スタックトレースが変わります。 これは「元の関数を書き換えない」ことの代償です。

4. デコレータの順番でキャッシュがログを飲んだ

「リトライしているはずなのにログが出ない」で30分潰しました。

withCache(withLog(withRetry(fetchPrice)))

キャッシュが一番外なので、2回目は中まで行きません。 ログもリトライも動きません。正しい動きでした。

包む順番は、外側から順に「先に効くもの」です。 紙に書いてから並べてください。

5. テストに import したら、モジュールの console.log が走った

strategy-after.js の末尾に for ループを置いたまま import したら、 テストの出力にループの結果が混ざりました。

# 対応している方法: credit, konbini, bank, paypay
# credit 1080

モジュールのトップレベルに書いたコードは、import された瞬間に走ります。 「動作確認用の console.log」を残したまま export しないでください。 上の記事のコードでは、テスト用に読む strategy-after.js からループを外しています。

6. EventEmitter の購読者が投げた例外で、注文処理まで落ちた

③の出力の最後の行です。

⚠️ 注文処理まで巻き添えで落ちた: Slack API が落ちている

emit は「非同期に投げっぱなし」ではありません。同期的に、その場で、登録順に全部呼びます。 分離しているつもりで、していませんでした。

購読者の中で必ず try / catch してください。 それが嫌なら、本物のキューに出す話になります。

7. シングルトンのテストが「単独では通る」

node --test singleton.test.js で B だけ落ちて、 node --test --test-name-pattern "B" で走らせると通りました。

「単独では通るのに、まとめて走らせると落ちる」は、ほぼ100%、状態の持ち越しです。 テストランナーを疑う前に、モジュールのトップレベルで書き換えているものを探してください。

8. やりすぎ版を「せっかく作ったから」と残しかけた

⑦のやりすぎ版を書き終わったとき、正直「悪くないな」と思いました。 makeCalculator('add') は、それらしく見えます。

これが一番危ないところです。 42行を書いた後だと、それが要らないと認めるのが難しくなります。

私が使っている歯止めは、「まず素朴に書いて、困ってから直す」という順番だけです。 先に素朴版を書いておくと、比べる相手が手元に残ります。


後片づけ

この記事で作ったものを消します。

bash
$ cd ~
$ ls ~/cslab/pattern
adapter.js  config.js  decorator.js  enemies.json  factory.js  mailer.js
naive.js  nullobject.js  observer.js  order-bad.js  order.js  order.test.js
over  over-main.js  over-main2.js  package.json  singleton-check.js
strategy-after.js  strategy-before.js  strategy.test.js
typeobject-after.js  typeobject-before.js

中身を確認してから消します。

bash
$ rm -rf ~/cslab/pattern
$ ls ~/cslab
(空、または他の記事のフォルダ)

rm -rf は戻せません。 パスを打つ前に、必ず ls で中身を見てください。

この記事では npm install を一度もしていないので、node_modules は残っていません。 SMTP_HOST を export した人は、ターミナルを閉じるか unset SMTP_HOST で戻してください。

bash
$ unset SMTP_HOST
$ echo "SMTP_HOST=[${SMTP_HOST}]"
SMTP_HOST=[]

まとめ — 理解できたこと

  • テストが書けない一番の原因は「中で new していること」。腕でもテストランナーでもない。ECONNREFUSED はその症状
  • 依存性注入は「引数で渡す」だけ。 DIコンテナも @Injectable も、個人開発では一度も要らなかった
  • DIが与えるのは「テストが通ること」ではなく「送ったかどうかを確かめられること」。 1通だけ送ったか、ゼロ件なら送っていないかが書けるようになった
  • new を無くすのではなく、new する場所を入口の1箇所に集める(合成ルート)。本物を知っているファイルは1つでよい
  • GoFの23個のうち、個人開発で出会うのは5つ程度。ストラテジー・アダプター・ファクトリ・オブザーバ・デコレータ
  • 5つのうち4つで、After のほうが行数が増えた。 パターンが減らすのは行数ではなく変更時に触る場所の数
  • EventEmitter はオブザーバの実装そのもの。 ただし emit は同期で、購読者の例外は呼び出し元まで届く
  • デコレータは高階関数で書ける。 包む順番で意味が変わり、fn.name とスタックトレースが失われる
  • JavaScript ではモジュールがシングルトン。 3回 import しても評価は1回、a === b になる
  • 書き換わる状態をモジュールに置くと、テストが順番に依存して落ちる。 2 !== 1 で実際に再現した
  • if (logger) は、何もしないロガーを渡せば消える(Null Object)。3個あった if が0個になった。ただし error まで黙らせない
  • 種類ごとにクラスを作るのをやめると、種類の追加がコードの追加でなくなる(Type Object)。JSONに1件足すだけで敵が増えた
  • 「2つの数を足す」に4つのパターンを重ねたら、1行が42行・1ファイルが6ファイルになった。 答えは同じ
  • やりすぎ版は拡張性でも負けた。 引き算を足すのに、素朴版は1行、やりすぎ版は2ファイル6行。しかもファクトリを修正している
  • 同じ変更を3回してから、初めてパターンを検討する(Rule of Three)。2回では、似ているだけなのか同じなのか分からない
  • 判断の言葉は「いま何に困っているか、1文で言えるか」。 「将来変わるかもしれない」は1文になっていない
  • レイヤード / MVC / ヘキサゴナル / イベント駆動 / マイクロサービスは、全部「変わるものと変わらないものを分ける」の言い換え。 違うのは分ける単位だけ
  • 困って直したら、勝手にヘキサゴナルの形になっていた。 名前を先に覚える必要はなかった

参考リンク


次に読む

この記事は 【深掘り】コンピュータ科学 の 19 / 25 本目です。

記事
← 前の記事プロセスとスレッドと競合状態 — たまにだけ数が合わない
→ 次の記事UML図とMermaid記法 — 図はすぐ嘘になる

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

›CS — Design Patterns
  • 依存性注入でテストが書けるようになる
  • パターンは困ってから当てる

この記事は、上の項目を実際に手を動かして確かめる回です。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次