Pythonのユニットテストで外部APIをモック

Pythonユニットテストにおける外部APIモックの詳細

Pythonのユニットテストにおいて、外部APIの呼び出しをシミュレートする「モック」は、テストの信頼性、速度、独立性を高める上で極めて重要な手法です。本稿では、外部APIモックの必要性、具体的な実装方法、および実践的なテクニックについて、詳細に解説します。

外部APIモックの必要性

ユニットテストの目的は、コードの最小単位（通常は関数やメソッド）が期待通りに動作することを確認することです。しかし、テスト対象のコードが外部APIに依存している場合、いくつかの問題が発生します。

• テストの不安定性: 外部APIは、ネットワークの状態、サーバーの負荷、またはAPI提供側の変更など、多くの外部要因に影響を受けます。これにより、テストが成功したり失敗したりと、不安定になる可能性があります。
• テストの遅延: 実際のAPI呼び出しは、ネットワーク通信やサーバー処理に時間を要するため、テスト実行に時間がかかります。テストスイート全体で数千、数万ものテストがある場合、この遅延は無視できないものとなります。
• テストのコスト: 外部APIによっては、利用に料金が発生するものもあります。テストのたびにAPIを呼び出すことは、予期せぬコストの発生につながる可能性があります。
• テストの独立性: 外部APIの利用がテストに必須となると、そのAPIが利用できない環境ではテストを実行できません。これは、CI/CDパイプラインの構築や、開発者のローカル環境でのテストを困難にします。
• テストデータの制御: 外部APIからの応答は、API提供側の都合で変更されることがあります。テストで特定の応答（正常系、異常系、エッジケースなど）を再現しようとしても、APIの実際の挙動に左右されてしまい、意図したテストができないことがあります。

これらの問題を解決するために、外部APIの呼び出しを「モック」することで、テスト対象のコードに、あたかも実際のAPIから応答が返ってきたかのような振る舞いをさせることができます。

`unittest.mock` モジュールの活用

Python標準ライブラリである `unittest.mock` モジュールは、モックオブジェクトを作成し、その振る舞いを制御するための強力なツールを提供します。このモジュールは、`mock` と `unittest` の両方のテストフレームワークと連携して使用できます。

`Mock` クラス

`Mock` クラスは、基本的なモックオブジェクトを作成するためのクラスです。`Mock` オブジェクトは、属性へのアクセスやメソッド呼び出しを記録し、必要に応じてカスタマイズされた応答を返すことができます。

基本的な使い方


from unittest.mock import Mock

# Mockオブジェクトの作成
mock_api_client = Mock()

# 属性へのアクセスをシミュレート
mock_api_client.api_key = "test_key"

# メソッド呼び出しをシミュレート
mock_api_client.get_user.return_value = {"id": 1, "name": "Test User"}

# メソッドが呼び出されたかどうかの確認
mock_api_client.get_user(user_id=1)
mock_api_client.get_user.assert_called_once_with(user_id=1)

# 属性へのアクセスが記録されているかの確認
print(mock_api_client.api_key)
print(mock_api_client.api_key.called) # 属性アクセスはcalled属性を持たない


この例では、`mock_api_client` というモックオブジェクトを作成し、`api_key` 属性と `get_user` メソッドを定義しています。`return_value` を設定することで、`get_user` メソッドが呼び出された際に返される値を指定できます。`assert_called_once_with` を使って、メソッドが期待通りに呼び出されたかを確認しています。

`patch` デコレータ/コンテキストマネージャー

`patch` は、既存のオブジェクト（関数、クラス、モジュールなど）を一時的にモックオブジェクトに置き換えるための強力な機能です。これにより、テスト対象のコードが依存する外部APIの呼び出し部分を、テスト内で簡単にモックすることができます。

デコレータとしての `patch`

テストメソッドにデコレータとして適用するのが一般的です。


from unittest.mock import patch
import requests # 外部APIを呼び出すライブラリを想定

# テスト対象の関数 (例)
def fetch_data_from_api(url):
response = requests.get(url)
response.raise_for_status() # エラーハンドリング
return response.json()

# テストコード
class TestApiFetching(unittest.TestCase):

@patch('requests.get') # 'requests.get' をモックする
def test_fetch_data_success(self, mock_get):
# モックオブジェクトの応答を設定
mock_response = Mock()
mock_response.json.return_value = {"data": "some value"}
mock_response.raise_for_status.return_value = None # 正常な応答をシミュレート
mock_get.return_value = mock_response

# テスト対象の関数を呼び出す
result = fetch_data_from_api("http://example.com/api/data")

# 期待される結果であることを確認
self.assertEqual(result, {"data": "some value"})

# requests.getが期待通りに呼び出されたか確認
mock_get.assert_called_once_with("http://example.com/api/data")
mock_response.raise_for_status.assert_called_once()
mock_response.json.assert_called_once()

@patch('requests.get')
def test_fetch_data_api_error(self, mock_get):
# APIエラーをシミュレート
mock_response = Mock()
mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError("404 Client Error")
mock_get.return_value = mock_response

# エラーが発生することを確認
with self.assertRaises(requests.exceptions.HTTPError):
fetch_data_from_api("http://example.com/api/nonexistent")

mock_get.assert_called_once_with("http://example.com/api/nonexistent")
mock_response.raise_for_status.assert_called_once()
mock_response.json.assert_not_called() # エラー時はjsonは呼ばれないはず


`@patch(‘requests.get’)` は、テストメソッド `test_fetch_data_success` の実行中に、`requests.get` 関数をモックオブジェクトに置き換えます。このモックオブジェクトは、テストメソッドの引数として渡されます (`mock_get`)。

コンテキストマネージャーとしての `patch`

特定のコードブロック内でのみモックを有効にしたい場合に便利です。


from unittest.mock import patch
import requests

# ... (fetch_data_from_api 関数は上記と同じ) ...

class TestApiFetchingContext(unittest.TestCase):

def test_fetch_data_with_context(self):
with patch('requests.get') as mock_get:
# モックオブジェクトの応答を設定
mock_response = Mock()
mock_response.json.return_value = {"status": "ok"}
mock_response.raise_for_status.return_value = None
mock_get.return_value = mock_response

result = fetch_data_from_api("http://example.com/api/status")

self.assertEqual(result, {"status": "ok"})
mock_get.assert_called_once_with("http://example.com/api/status")

# withブロックを抜けると、requests.getは元の実装に戻る
# ここでrequests.getを直接呼ぶと、実際のAPI呼び出しが発生する


モックオブジェクトの振る舞いのカスタマイズ

モックオブジェクトは、様々な方法でその振る舞いをカスタマイズできます。

• `return_value`: メソッドが呼び出されたときに返される値を指定します。
• `side_effect`: メソッドが呼び出されたときに、例外を発生させたり、複数の値を順番に返したり、あるいは別の関数を実行させたりすることができます。
• `configure_mock`: 複数の属性やメソッドの振る舞いを一度に設定できます。

`side_effect` の例


from unittest.mock import Mock

mock_object = Mock()

# 例1: 例外を発生させる
mock_object.method_that_raises.side_effect = ValueError("Invalid input")
with self.assertRaises(ValueError):
mock_object.method_that_raises()

# 例2: 複数の値を順番に返す
mock_object.get_next_item.side_effect = [1, 2, 3, "done"]
self.assertEqual(mock_object.get_next_item(), 1)
self.assertEqual(mock_object.get_next_item(), 2)
self.assertEqual(mock_object.get_next_item(), 3)
self.assertEqual(mock_object.get_next_item(), "done")
with self.assertRaises(StopIteration): # side_effectで指定したシーケンスを使い切るとStopIterationが発生
mock_object.get_next_item()

# 例3: 別の関数を実行する
def custom_logic(arg):
return f"Processed: {arg}"
mock_object.process_data.side_effect = custom_logic
self.assertEqual(mock_object.process_data("input"), "Processed: input")


`patch.object`

`patch` はモジュールレベルのオブジェクトを置き換えるのに適していますが、クラスのインスタンスのメソッドなどをモックしたい場合は `patch.object` が便利です。


from unittest.mock import patch

class MyService:
def __init__(self, client):
self.client = client

def get_data(self, item_id):
return self.client.fetch(item_id)

class ApiClient:
def fetch(self, item_id):
# 実際にはAPIを呼び出す
pass

# テストコード
class TestMyService(unittest.TestCase):

def test_get_data(self):
mock_client = Mock()
mock_client.fetch.return_value = {"id": 1, "value": "test"}

service = MyService(mock_client)
result = service.get_data(1)

self.assertEqual(result, {"id": 1, "value": "test"})
mock_client.fetch.assert_called_once_with(1)

@patch.object(ApiClient, 'fetch') # ApiClientクラスのfetchメソッドをモック
def test_get_data_with_patch_object(self, mock_fetch):
mock_fetch.return_value = {"id": 2, "value": "patched"}

# ApiClientのインスタンスを作成し、MyServiceに渡す
# このインスタンスのfetchメソッドはモックされている
client_instance = ApiClient()
service = MyService(client_instance)

result = service.get_data(2)

self.assertEqual(result, {"id": 2, "value": "patched"})
mock_fetch.assert_called_once_with(2)


`patch.object(ApiClient, ‘fetch’)` は、`ApiClient` クラスの `fetch` メソッドをモックします。これにより、`ApiClient` のインスタンスが作成され、その `fetch` メソッドが呼び出されると、モックされた振る舞いが実行されます。

モック化のアンチパターンと注意点

外部APIモックは強力なツールですが、乱用するとテストの価値を損なう可能性があります。

• 過剰なモック: テスト対象のコードが依存するすべてのものをモックしてしまうと、テストが実際のコードの振る舞いをほとんど反映しなくなります。APIクライアントの内部実装まで細かくモックする必要はありません。
• モックと実装の同期ずれ: モックの定義と実際のAPIの仕様が異なると、テストはパスしても、本番環境でエラーが発生する可能性があります。モックは、APIの「インターフェース」を模倣するべきです。
• テスト対象のコードの隠蔽: テスト対象のコードが、モックされたAPIクライアントとのやり取りだけで完結してしまうと、そのコード自体が複雑すぎる、あるいは設計が不適切であるという問題を見逃してしまう可能性があります。

まとめ

Pythonのユニットテストにおける外部APIモックは、テストの信頼性、速度、独立性を確保するために不可欠な技術です。`unittest.mock` モジュールの `Mock` クラスや `patch` デコレータ/コンテキストマネージャーを効果的に活用することで、外部APIの呼び出しをシミュレートし、テスト対象のコードを隔離して検証することができます。

モックの目的は、あくまで「テスト対象のコードが、外部APIからの応答をどのように処理するか」を検証することにあります。API自体の動作をテストしたい場合は、統合テストやエンドツーエンドテストで、実際のAPI（またはステージング環境のAPI）を利用する必要があります。

モックは、テストコードに複雑さを追加する側面もありますが、そのメリットは計り知れません。これらのテクニックを理解し、適切に適用することで、より堅牢で保守しやすいテストスイートを構築することができます。