---
title: "スケルトンテストとは？未実装を検証するテストの書き方と7言語の実行例【pytest 9.2対応】"
url: "https://www.issoh.co.jp/tech/details/9086/"
published: 2025-10-01
updated: 2026-11-08
categories: ["テスト"]
publisher: "株式会社一創"
---

# スケルトンテストとは？未実装を検証するテストの書き方と7言語の実行例【pytest 9.2対応】

スケルトンテストは、型や関数の枠だけを先に作った未実装のコード（スケルトンコード）に対して、「まだ未実装であること」を確かめるテストです。いまは通り、誰かが中身を実装した瞬間に落ちます。そのため、実装者はテストを本物に書き換えないとCIを通せません。

この記事では、この手法の出どころと定義、プログラミングでいう「未実装」の意味と英語表記を確認したうえで、送料計算の関数を題材に pytest 9.2.0・Jest 30.5.2・Vitest 5.1.0・JUnit 6.1.3・Kotlin・Go・Rust・RSpec で実際に「未実装→実装」と書き換えたときの判定を示します（2026年11月8日に手元で実行）。skip や todo では同じ効果が出ない理由と、使わないほうがよい場面も扱います。

## まとめ：スケルトンテストの要点と使いどころ

- スケルトンテストは、未実装の関数が未実装の例外やエラーを返すことを検証するテスト。実装すると落ちるので、テストの書き換えが実装作業の一部になる
- この意味での呼び名は、ナレッジワークの石川宗寿氏が2025年9月27日の Zenn 記事で示したもの。一般に定着した用語ではなく、英語圏では expected failure（期待失敗）や pending と呼ばれる仕組みが近い
- 「未実装」は英語で not implemented。ただし未実装を表す例外の意味は言語で割れており、Python・Kotlin・Rust の todo!・.NET の NotImplementedException は「まだ書いていない」、Java の UnsupportedOperationException と Ruby の NotImplementedError は本来「対応しない」を表す
- 書き方は2通り。原典どおり「未実装の例外」を検証する方法と、本来のテストを先に書いて期待失敗の印を付ける方法（pytest の xfail(strict=True)、Jest の test.failing など）
- skip・todo・JUnit の @Disabled・Go の t.Skip は、実装後もスキップのまま通るので強制力がない。pytest の xfail も、マーカーやプロジェクト設定で strict を有効にしていなければ実装後に通過する
- 向くのは新しい型や関数を足す開発と、移行先を新規に作るリファクタリング。既存コードを直接書き換える修正や、スケルトンを作るまでもない小さな変更には使わない

## スケルトンテストの意味と提唱元

### 「未実装であること」を確かめるテストという定義

スケルトンテストという呼び名は、株式会社ナレッジワークのソフトウェアエンジニア石川宗寿氏が Zenn に公開した記事[「「スケルトンテスト」でテストの作成を自分に強制する」](https://zenn.dev/knowledgework/articles/10a3ad55d84503)（2025年9月27日）によるものです。記事中で石川氏は、スケルトンコードが本当に未実装であるかを確認するテストを「私の定義する『スケルトンテスト』」と書いており、個人の命名であることを明示しています。

原典の例は Kotlin です。TODO() は呼ばれると NotImplementedError を投げる標準ライブラリの関数で（[Kotlin公式リファレンス](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-t-o-d-o.html)の記述は「Always throws NotImplementedError stating that operation is not implemented.」）、テスト側は assertFailsWith<NotImplementedError> でその例外を検証します。関数を実装すると例外が出なくなり、テストが落ちます。

### 「テストの雛形」という別の意味との関係

原典の脚注には、テストの枠組みだけを定義してロジックを書いていない状態、つまり「テストのスケルトン」をスケルトンテストと呼ぶ用法もあると書かれています。石川氏の定義はこれと別物ですが、実装時に書き換える起点になるので、結果としてテストの雛形の役目も果たします。本記事では原典の定義（スケルトンコードに対するテスト）で扱います。

## プログラミングでの「未実装」の意味と英語表記

プログラミングで「未実装」は、関数やメソッドの名前・引数・戻り値の型は決まっているが、中身の処理がまだ書かれていない状態を指します。英語では not implemented、形容詞なら unimplemented と書き、例外名やエラーメッセージにもこの語がそのまま入ります。Python の NotImplementedError、Rust の unimplemented!() が出すメッセージ「not implemented」、gRPC のステータスコード UNIMPLEMENTED がその例です。スケルトンテストが検証するのは、未実装の関数がこうした例外やパニックで止まることです。

### 「まだ書いていない」と「対応しない」の区別（言語別の公式定義）

未実装を表す例外やマクロの意味は、公式ドキュメントを読むと「後で実装する」と「この環境や型では対応しない」の2つに割れています。スケルトンに置くべきなのは前者です。

| 言語     | 例外・マクロ                        | 公式の意味          | スケルトン |
| ------ | ----------------------------- | -------------- | ----- |
| Python | NotImplementedError           | 開発中・抽象メソッド     | 向く    |
| Kotlin | TODO()                        | 操作が未実装         | 向く    |
| Rust   | todo!()                       | 後で実装する意図       | 向く    |
| Rust   | unimplemented!()              | 実装予定を示さない      | 代用    |
| .NET   | NotImplementedException       | 開発中で後で実装       | 向く    |
| .NET   | NotSupportedException         | 実装できない操作       | 向かない  |
| Java   | UnsupportedOperationException | 操作をサポートしない     | 代用    |
| Ruby   | NotImplementedError           | このプラットフォームで非対応 | 代用    |
| gRPC   | UNIMPLEMENTED                 | 未実装または非対応・無効   | 代用    |

[Python の公式ドキュメント](https://docs.python.org/3/library/exceptions.html#NotImplementedError)は、NotImplementedError を抽象メソッドや「開発中のクラスで本当の実装をまだ追加する必要がある」ことを示す例外と定め、そもそもサポートしない演算子やメソッドには使うべきでない（定義しないか None を設定する）と書いています。.NET はさらに明確で、[NotImplementedException の解説](https://learn.microsoft.com/en-us/dotnet/api/system.notimplementedexception?view=net-10.0)が、開発中で後から実装するメンバーにはこの例外を、インターフェースの実装が不可能な場合は NotSupportedException を、特定のプラットフォームで動かない機能は PlatformNotSupportedException を使うよう分けています。Rust も[unimplemented! のドキュメント](https://doc.rust-lang.org/std/macro.unimplemented.html)で、todo! は後で実装する意図を伝えるが unimplemented! はそうした主張をしない、と違いを説明しています。

逆の側にいるのが Java と Ruby です。[Java SE 25 の UnsupportedOperationException](https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/UnsupportedOperationException.html) は「Thrown to indicate that the requested operation is not supported.」で、変更できないリストへの追加などで投げられる例外です。Java には「まだ書いていない」専用の標準例外が無いので、スケルトンでは流用になります。Ruby の NotImplementedError も、本来は fork や fsync のようにOSや処理系が対応していない機能のための例外です（後述）。

流用の弱点は、本当に対応しない操作と見分けがつかないことです。JUnit 6.1.3 で確かめると、List.of(1).add(2) もメッセージが null の UnsupportedOperationException を投げ、例外のクラスだけを照合する assertThrows はこれも通しました。Java・Ruby・gRPC では、スケルトンの例外メッセージに課題番号（例の「#123 で実装」）を入れ、テストでメッセージまで照合してください。

## スケルトンコード・ウォーキングスケルトンとの違い

「スケルトン」が付く用語は分野ごとに指すものが違います。混同しやすい4つを並べます。

| 用語          | 指すもの                 | 動くか            |
| ----------- | -------------------- | -------------- |
| スケルトンコード    | 型・関数などの枠組みを定めた未実装コード | 空処理・仮の戻り値・例外など |
| スケルトンテスト    | スケルトンコードが未実装であることの検証 | 未実装の間だけ通る      |
| ウォーキングスケルトン | 端から端まで通る最小のシステム      | 小さな機能が動く       |
| スケルトンスクリーン  | 読み込み中に出す灰色の枠のUI      | 画面表示のみ         |

スケルトンコードそのものの書き方は[スケルトンコードの意味と6言語での書き方](/tech/details/9085/)で、UIのスケルトン表示は[スケルトンスクリーンとスピナーの使い分け](/tech/details/6971/)で扱っています。

ウォーキングスケルトンは Alistair Cockburn 氏の用語で、同氏は「A Walking Skeleton is a tiny implementation of the system that performs a small end-to-end function.」と定義しています（[c2 wiki に引用された定義](https://wiki.c2.com/?WalkingSkeleton)）。こちらは実際に動く最小構成を先に作ってアーキテクチャを確かめる手法で、中身が空のまま「未実装」を検証するスケルトンテストとは目的が別物です。

## スケルトンテストが実装時にテストの更新を強制する仕組み

スケルトンテストは、スケルトンコードを先に用意する開発で使います。ここでは、プルリクエストを「設計」と「実装」の2段に分ける運用例で説明します。

- 設計のプルリクエスト：スケルトンコードとスケルトンテストだけを出す。テストは未実装を検証しているのでCIは通る。レビュアーは関数の分け方や引数、テストすべき対象かどうかに集中できる
- 実装のプルリクエスト：関数の中身を書くとスケルトンテストが落ちる。CIを通すには、スケルトンテストを本来の振る舞いのテストに書き換えるしかない。レビュアーはケースの網羅や期待値の正しさを見ればよい

テストを書かずに済ませたい実装者は、スケルトンテストを消すことになります。石川氏が指摘するとおり、テストを足さなかった差分よりテストを消した差分のほうがレビューで目に付きます。原典は、後で書くと決めたテストが忘れられやすいことに加え、テストファイルをゼロから作る心理的なハードルも挙げています。スケルトンテストは前者を差分に残る形に変え、後者は書き換えの起点を用意することで下げます。プルリクエストの分け方やレビュー必須化の設定は[GitHubのPull Requestの作り方とレビュー必須化の決め方](/tech/details/18004/)を参照してください。CIでテストの通過をマージの条件にする仕組みづくりは、[DevOps・CI/CD導入支援](/service/system/devops/)でも扱っています。

### 実装を他の人やAIエージェントに渡す場面

設計者と実装者が別の場合、スケルトンテストは「この関数にはテストが必要」という指示を、CIが止める形で伝えます。原典は、テストファイルが先にあると複数人やAIエージェントに並行して実装させたときにコンフリクトが起きにくい点も挙げています。共通のフェイク（依存先を代替する簡易実装）やフィクスチャ（テスト用のデータや環境の準備）をスケルトンテストの段階で用意しておくと、実装者ごとにばらばらのテスト部品が生まれるのも防げます。フェイクとスタブ・モックの区別は[モックとスタブの違いとテストダブル5分類](/tech/details/13505/)で整理しています。

ただし、AIエージェントに実装させるときは「スケルトンテストを削除しただけ」「期待する例外を変えただけ」の差分でもCIは通ります。レビューでは、スケルトンテストが振る舞いのテストに置き換わったかを確認してください。

## 書き方は2方式：未実装の検証と期待失敗マーカー

以下、仕様が「合計5,000円以上は送料無料、それ未満は550円」の送料計算関数を例にします。未実装の段階では NotImplementedError を投げます。

```
def shipping_fee(total: int) -> int:
    raise NotImplementedError("#123 で実装")
```

本体を pass や … だけにしたスケルトンは、呼ぶと None を返して止まりません。pytest 9.2.0 で試すと、下の方式Aのテストは設計の段階から DID NOT RAISE NotImplementedError で落ちました。スケルトンの本体には必ず例外を置きます。

### 方式A：未実装の例外の検証（原典の書き方）

原典と同じく、未実装の例外が出ることをテストします。pytest では pytest.raises を使います。

```
import pytest
from shipping import shipping_fee

def test_shipping_fee_is_unimplemented():
    with pytest.raises(NotImplementedError):
        shipping_fee(3000)
```

未実装の間は passed です。関数を実装して pytest 9.2.0 で実行すると、次のように落ちます。

```
E       Failed: DID NOT RAISE NotImplementedError
```

実装者は、このテストを「5,000円で0円」「4,999円で550円」といった振る舞いのテストに書き換えることになります。

### 方式B：本来のテストと期待失敗マーカーの組み合わせ

もう1つの書き方は、期待値まで決まった本来のテストを先に書き、「いまは失敗するのが正しい」という印を付ける方法です。pytest では xfail マーカーに strict=True を付けます。

```
import pytest
from shipping import shipping_fee

@pytest.mark.xfail(raises=NotImplementedError, strict=True, reason="#123 で実装")
def test_free_over_5000():
    assert shipping_fee(5000) == 0
```

未実装の間は XFAIL（想定どおりの失敗）として扱われ、テスト全体は成功します。実装してテストが通るようになると、pytest は想定外の成功として失敗に変えます。

```
[XPASS(strict)] #123 で実装
```

実装者がやることは、マーカーの行を消すだけです。fixture や parametrize を含む pytest の書き方全般は[pytestの使い方と書き方](/tech/details/7527/)にまとめています。

### 未実装例外の検証と期待失敗マーカーの選択基準

期待値が設計の段階で決まっているなら方式Bを使います。仕様がテストとして先に固定されるので、実装者が期待値を自分の実装に合わせて変えれば、その変更がレビューの差分に残ります。送料計算のように、仕様書に「5,000円で0円、4,999円で550円」と境界値まで書かれている場合がこれに当たります。設計の段階ではインターフェースしか決まっておらず、ケースの洗い出しも実装者に任せたいなら方式Aです。方式Aは、テストの中身を考える作業そのものを実装者に強制します。

原典の主眼は「実装者にテストを書かせる」ことなので、本来の意味でのスケルトンテストは方式Aです。方式Bは同じ強制力を持つ近縁の書き方と考えてください。

## 言語・フレームワーク別の書き方と実装後の判定

各フレームワークで「未実装→実装」と書き換えて実行した結果をまとめます（2026年11月8日に手元で実行）。期待失敗マーカーを標準で持つかどうかで、方式Bが使えるかが決まります。

| 言語・FW               | 未実装の表し方                       | 方式A             | 方式B                |
| ------------------- | ----------------------------- | --------------- | ------------------ |
| Python／pytest 9.2.0 | NotImplementedError           | pytest.raises   | xfail(strict=True) |
| JS／Jest 30.5.2      | throw new Error               | toThrow         | test.failing       |
| JS／Vitest 5.1.0     | throw new Error               | toThrow         | test.fails         |
| Ruby／RSpec 3.13.7   | NotImplementedError           | raise\_error    | pending            |
| Java／JUnit 6.1.3    | UnsupportedOperationException | assertThrows    | 標準機能なし             |
| Kotlin 2.4.21       | TODO()                        | assertFailsWith | 標準機能なし             |
| Go 1.27.3           | codes.Unimplemented 等         | エラー値を比較         | 標準機能なし             |
| Rust 1.99.1         | todo!()                       | should\_panic   | 標準機能なし             |

方式Aは全ての組み合わせで、実装後にテストが落ちることを確認しました。方式Bの列にある4つも、実装がテストを通すようになった時点で失敗に変わります（実装に誤りがあってテストが落ちている間は、Jest・Vitest・RSpec では緑のままです）。

### Jest・Vitestの期待失敗テスト

Jest では test.failing（Jest 28.1.0 で追加）、Vitest では test.fails が方式Bに当たります。Jest の test.failing は既定の jest-circus ランナーでのみ使え、jest-jasmine2 に切り替えたプロジェクトでは使えません。

```
const { shippingFee } = require("./shipping");

test.failing("5000円以上は送料無料", () => {
  expect(shippingFee(5000)).toBe(0);
});
```

実装後の Jest 30.5.2 の出力は Failing test passed even though it was supposed to fail. Remove \`.failing\` to remove error. で、消すべきものまで示してくれます。Vitest 5.1.0 は未実装の間を「1 expected fail」と数え、実装後は Error: Expect test to fail で落ちます。どちらも pytest の raises のように失敗の種類を絞る引数は持たないため、未実装以外の理由で失敗していても成功扱いになります（後述）。Vitest の設定や書き方全般は[Vitestの使い方と書き方](/tech/details/2867/)で扱っています。

### JUnit 6とKotlinの方式Aによる書き方

JUnit 6.1.3 のユーザーガイドが挙げるアノテーションには、成功したら失敗に変わる期待失敗の印がありません。Java では先述のとおり UnsupportedOperationException を流用し、assertThrows が返す例外のメッセージまで照合します。

```
@Test
void feeIsUnimplemented() {
    var e = assertThrows(UnsupportedOperationException.class, () -> Shipping.fee(3000));
    assertEquals("#123 で実装", e.getMessage());
}
```

JUnit 6.1.3 で実装後に実行すると Expected java.lang.UnsupportedOperationException to be thrown, but nothing was thrown. で失敗します。同じクラスに置いた @Disabled のテストは、実装後も skipped のままでした。

Kotlin は原典どおり TODO() と assertFailsWith の組み合わせです。kotlinc 2.4.21 と JUnit 6.1.3 で実行すると、TODO(“#123 で実装”) の例外メッセージは An operation is not implemented: #123 で実装 で、実装後は Expected an exception of class kotlin.NotImplementedError to be thrown, but was completed successfully with the result: <550>. と実装の戻り値まで出して落ちました。

```
fun shippingFee(total: Int): Int = TODO("#123 で実装")

@Test
fun feeIsUnimplemented() {
    assertFailsWith<NotImplementedError> { shippingFee(3000) }
}
```

### Goのエラー値とcodes.Unimplementedによる未実装表現

Go には try/catch の例外機構がなく、未実装はエラー値で返すのが一般的です。原典は gRPC の codes.Unimplemented を使う例を示しています。protoc-gen-go-grpc が生成する Unimplemented〜Server も、未実装のメソッドに対して codes.Unimplemented と「method 〜 not implemented」というメッセージを返すので、gRPC のサーバーではこの慣例にそろえると扱いやすくなります。

注意点は、このコードを返すのがアプリだけではないことです。[gRPC のステータスコード一覧](https://github.com/grpc/grpc/blob/master/doc/statuscodes.md)は UNIMPLEMENTED を「not implemented or is not supported/enabled in this service」と定義し、サーバーにメソッドが無いときや、クライアントの圧縮方式にサーバーが対応しないときにもフレームワーク自身がこのコードを返すと書いています。クライアント経由でテストすると、サービスの登録漏れでもスケルトンテストが通ってしまうので、コードとメッセージを両方比べます。

```
func TestFeeIsUnimplemented(t *testing.T) {
	_, err := Fee(3000)
	st := status.Convert(err)
	if st.Code() != codes.Unimplemented || st.Message() != "#123 で実装" {
		t.Fatalf("status = %v %q, want Unimplemented", st.Code(), st.Message())
	}
}
```

Go 1.27.3 で実装後に実行すると status = OK “”, want Unimplemented で落ちます。gRPC を使わないコードなら、パッケージに ErrNotImplemented のような番兵エラーを定義して errors.Is で比較すれば同じ形になります。生成コードの扱いは[gRPC Goの実装とprotoc-gen-go-grpcの生成手順](/tech/details/17217/)で解説しています。

### Rustのtodo!とunimplemented!の使い分け

Rust の todo!() は「not yet implemented」、unimplemented!() は「not implemented」というメッセージでパニックします。[標準ライブラリのドキュメント](https://doc.rust-lang.org/std/macro.todo.html)は、todo! は後で実装する意図を示すマクロだと説明しています。スケルトンには todo! を置き、テストはメッセージまで指定します。rustc 1.99.1 で todo!(“#123 で実装”) のパニックメッセージを取り出すと not yet implemented: #123 で実装 となり、expected の部分一致は保たれます。

```
#[test]
#[should_panic(expected = "not yet implemented")]
fn shipping_fee_is_unimplemented() {
    shipping_fee(3000);
}
```

実装後は test did not panic as expected で失敗します。expected を省くと、未実装以外の理由のパニック（配列の範囲外アクセスなど）でもテストが通ってしまいます。

### RubyのNotImplementedErrorとrescueの捕捉範囲

Ruby の NotImplementedError は StandardError ではなく ScriptError の子クラスです（Ruby 4.0.6 で継承関係が NotImplementedError、ScriptError、Exception の順であることを確認）。そのため、例外クラスを指定しない rescue => e では捕まらず、呼び出し元へ伝わります。[Ruby 4.0 の公式ドキュメント](https://docs.ruby-lang.org/en/4.0/NotImplementedError.html)の定義は「Raised when a feature is not implemented on the current platform」で、fork や fsync のようにOSや処理系が対応していない機能のための例外です。スケルトンでの使用は慣例上の転用なので、メッセージに課題番号を入れておきます。RSpec の raise\_error はクラスを省いても捕まえますが、NoMethodError などでも通ってしまうので、expect { shipping\_fee(5000) }.to raise\_error(NotImplementedError, “#123 で実装”) とクラスとメッセージを指定します。方式Bは RSpec の pending で、rspec-core 3.13.7 では実装後に Expected pending ‘#123 で実装’ to fail. No error was raised. で失敗します。

## skip・todoでは代わりにならない理由

「未実装のテストに印を付ける」機能はどのフレームワークにもありますが、多くは実装後も何も言いません。手元の実行結果は次のとおりです。

| 書き方                            | 未実装時    | 実装後         |
| ------------------------------ | ------- | ----------- |
| Jest／Vitest の test.todo        | todo    | todo のまま    |
| JUnit の @Disabled              | skipped | skipped のまま |
| Go の t.Skip                    | SKIP    | SKIP のまま    |
| pytest の xfail（strict設定なし・既定値） | XFAIL   | XPASS で成功扱い |
| pytest の xfail(strict=True)    | XFAIL   | 失敗          |

skip や todo は「書くべきテストがある」という記録にはなりますが、実装したかどうかを見ていません。実装が終わってもCIは緑のままで、印は放置されます。スケルトンテストが成り立つのは、未実装という状態をテストが検証しているからです。

pytest の xfail は既定では strict ではありません。プロジェクト全体で strict にするには、pyproject.toml に次の設定を入れます。pytest 9.2.0 で、マーカー側に strict を書かないテストも実装後に失敗するようになることを確認しました。設定名は pytest 9.0 で xfail\_strict から strict\_xfail に変わり、旧名も別名として受け付けられます（[pytest公式リファレンス](https://docs.pytest.org/en/stable/reference/reference.html#confval-strict%5Fxfail)）。pytest 8.4.2 に strict\_xfail を書くと警告が出るだけで strict にならず、XPASS が成功扱いのまま残ります。旧名は9系でも通るので、版が混在するなら xfail\_strict が安全です。

```
[tool.pytest.ini_options]
xfail_strict = true
```

## スケルトンテストの失敗パターンと使わないほうがよい場面

### 未実装以外の失敗の隠蔽

方式Bでいちばん起きやすい事故です。pytest で raises を付けない xfail は、どんな理由の失敗でも XFAIL として通します。実装途中に属性名を打ち間違えて AttributeError が出た状態で pytest 9.2.0 を実行すると、raises なしのテストは XFAIL のまま緑で、raises=NotImplementedError を付けたテストだけが失敗として報告されました。Jest の test.failing と Vitest の test.fails には失敗の種類を絞る手段がありません。失敗の種類まで確かめたいなら toThrow(“Not implemented”) でメッセージを指定する方式Aを使い、方式Bは期待失敗のまま長く置かないことが対策になります。

### テスト基盤がNotImplementedErrorをskipに変える場合

独自のテストランナーや共通の基底クラスが「NotImplementedError は未対応の印」とみなしてスキップに変換していると、スケルトンテストが実行されないことがあります。テスト本体の pytest.raises が先に例外を捕まえる方式Aなら検証は成り立ちますが、fixture や setUp などのセットアップで未実装の関数を呼んでいて、そこで捕まってスキップされると、テスト本体が走らず、実装後に落ちる仕組みも働きません。PyTorch のベンチマーク集 TorchBenchmark では、モデルの get\_module() が NotImplementedError を投げると test.py がそれを受け取ってスキップし、そのモデルの単体テストが全部飛ぶ問題が[issue #567](https://github.com/pytorch/benchmark/issues/567)（2021年11月18日）で報告されました。導入前に、conftest.py や基底クラスに NotImplementedError を捕まえて skip を呼ぶ処理がないか grep で確認してください。

### 実装されないスケルトンの放置

スケルトンテストは、実装されなければいつまでも緑です。機能が後回しになったり取りやめになったりすると、未実装の関数とそのテストが残り続けます。例外のメッセージに課題番号（例の #123）を入れておくと、grep で一覧を出し、閉じた課題に紐づくものを掃除できます。取りやめが決まった時点で、関数ごと消してください。

### 既存コードの直接修正と小さな変更

原典も、スケルトンテストはスケルトンコードが書けることが前提だと断っています。既存の関数の中身を直接書き換える修正には、未実装の段階がありません。数行で済む変更のためにスケルトンのプルリクエストを分けるのも手間が見合いません。こうした場合は、いつもどおり実装とテストを同じプルリクエストで出します。一方、移行先のコードを新しく作り、フィーチャーフラグで切り替えるリファクタリングでは、移行先がスケルトンから始まるので使えます。

## TDD（テスト駆動開発）との違い

TDD は、失敗するテストを1本書き、それを通す最小のコードを足す手順を数分単位で繰り返す手法です。テストが先にある点はスケルトンテストと共通しますが、時間の単位と目的が違います。

- TDD の失敗するテスト（Red）は、数分後に自分で通すためのもので、通常は通してからコミットする
- スケルトンテストは、未実装の状態のまま緑でマージされ、自分か別の人が実装するまで残る
- TDD はテストで実装を導く設計手法、スケルトンテストは実装時のテスト漏れを防ぐ仕組み

両者は組み合わせられます。TDDで進めるなら、実装前にスケルトンテストを期待する振る舞いのテストへ書き換え、その失敗を確認してから、通るように実装します。TDD の手順は[TDD（テスト駆動開発）のRed・Green・Refactorの手順](/tech/details/8496/)で、同じ送料計算の例を使って解説しています。単体・結合・E2E のどこにテストを置くかは[テストピラミッドの配分](/tech/details/13289/)を参照してください。スケルトンテストは主に単体テストの層で使います。

## よくある質問

### スケルトンテストとは何ですか？

型や関数の枠だけを作った未実装のコードに対して、未実装の例外やエラーが返ることを確かめるテストです。実装すると落ちるため、実装者はテストを本物に書き換えないとCIを通せません。この意味での呼び名は、ナレッジワークの石川宗寿氏が2025年9月の Zenn 記事で示したものです。

### skeleton test は英語でも通じますか？

この意味での skeleton test は、英語圏で定着した用語とは言えません。近い仕組みは expected failure（期待失敗）や pending と呼ばれ、pytest の xfail、Jest の test.failing、RSpec の pending が該当します。英語で説明するときは、仕組みを具体的に言うほうが誤解がありません。

### JUnitで「実装されたら落ちるテスト」を書くにはどうしますか？

未実装の関数から UnsupportedOperationException を投げ、assertThrows でその例外とメッセージを検証します。@Disabled は実装後もスキップのままで代わりになりません。

### PythonのNotImplementedとNotImplementedErrorは何が違いますか？

未実装を示す例外は NotImplementedError です。NotImplemented は比較演算などで「この型の組み合わせは扱えない」と返すための定数で、raise NotImplemented と書くと TypeError: exceptions must derive from BaseException になります。

### Kotlinの TODO() と // TODO コメントは何が違いますか？

TODO() は呼ばれると NotImplementedError を投げる関数で、戻り値の型が Nothing なのでどの型の関数本体にも置けます。// TODO はただのコメントで、実行時には何も起きません。スケルトンテストで検証できるのは TODO() だけです。

## 関連記事

- [スケルトンコードとは？意味と書き方を6言語の実行例で解説｜スタブとの違い](/tech/details/9085/)
- [TDD（テスト駆動開発）とは？Red・Green・Refactorの手順をpytestとJUnit 6の実行例で解説](/tech/details/8496/)
- [pytestの使い方と書き方｜fixture・parametrize・docstringの扱いまで【9.2対応】](/tech/details/7527/)
- [モックとは？スタブとの違い・テストダブル5分類と5言語の書き方を実行例で解説](/tech/details/13505/)
- [テストピラミッドとは？単体・結合・E2Eの配分と実装者向けテスト戦略設計](/tech/details/13289/)

---

出典: [スケルトンテストとは？未実装を検証するテストの書き方と7言語の実行例【pytest 9.2対応】](<https://www.issoh.co.jp/tech/details/9086/>)（株式会社一創）
