【Python】死ぬほどモックで沼ってたのでその過程でClaude君が出してくれた対策を並べた

はじまり#

リサちゃん

これ何時になったら終わるの？？

135ml

沼のようだ。

なんでこんなに沼っているんだ#

何時まで経っても解決できない僕とClaude君。最初はClineにソースを読ませて解決しようとしたんですけど、読ませるにはファイルがすくすくとデカく育っていたもので、初回のデバッグの失敗を機に、Claude君と直接チャットしながらコードペタペタして解決に挑みました。しかし・・・、大体4時間ぐらい沼っていましたかね。それでも全然解決しなくて、まあ結局解決しなくて、最終的にはメソッドをモック対象のメソッドと同じファイル内に置いて終わらせたんですけど。うーん、結局何が原因だったんだろう？こいつも原因の一つだったのだろうか・・・。デコレータァァァ！！

1
@wrap_with_debug_log
2
def fetch_notion(self, endpoint: str, method: str, payload: dict) -> requests.Response:
3
    """
4

5
    """
6
    func_name = "notion_util.fetch_notion"
7
    args = [endpoint, method, payload]
8
    result_to_print_1 = f" with args: {args}"
9
    print(f"[DEBUG] {func_name}: Entering function with args: {args}")
10

11
    if endpoint is None:
12
        raise ValueError("'endpoint' must not be None.")
13
    if method is None:
14
        raise ValueError("'method' must not be None.")
15
    if payload is None:
16
        raise ValueError("'payload' must not be None.")
17
    if endpoint == "":
18
        raise ValueError("'endpoint' must not be empty.")
19
    if method == "":
20
        raise ValueError("'method' must not be empty.")
21
    if payload.__class__.__name__ != "dict":
22
        raise TypeError("'payload' must be dict type.")
23
    pprint("information to request Notion API...")
24
    pprint(endpoint)
25
    pprint(method)
26
    pprint(payload)
27

28
    headers = {
29
        "Notion-Version": "2022-06-28",
30
        "Authorization": f"Bearer {self.get_notion_integration_token()}",
31
        "Content-Type": "application/json"
32
    }
33
    pprint(f"requesting to Notion API...")
34
    if method == "GET":
35
        response = requests.request(
36
            method=method,
37
            url=endpoint,
38
            headers=headers,
39
            timeout=60
40
        )
41
    else:
42
        response = requests.request(
43
            method=method,
44
            url=endpoint,
45
            headers=headers,
46
            data=json.dumps(payload),
47
            timeout=60
48
        )
49
    if not response.ok:
50
        print(f"Error: with HTTP status code: {response.status_code} - {response.text}")
51
    response.raise_for_status()
52
    # response.encoding = response.apparent_encoding
53
    # response.encoding = "Shift_JIS"
54
    response.encoding = "utf-8"
55
    pprint(f"received response.")
56
    # pprint(response.text)
57
    pprint(response.status_code)
58
    pprint(response.encoding)
59
    print(f"[DEBUG] {func_name}: Exiting function{result_to_print_1}")
60

61
    return response

メソッドの名前の上にチョコンと付いているグルグルが座っていた所為で4時間も意味のない時間が過ぎ去っていたのかもしれません・・・。まあ、ログを出力するために書いたんですけどね。APIリクエストの結果のログって大事ですから。ということで今回は、そんな意味がなかった4時間を少しでも意味のあるものにするために、Claude君がその4時間の中でプリプリ出してくれたモックの手法を並べてみることにしました。まあ、途中で出してくれた手法によって、デコレータがモックの邪魔をしていたことが分かりましたからね。あっ、ちなみに本記事には、デコレータを付けたメソッドのモックの仕方は載っていません。試しに一回、Claude君にプリッと出してもらいましたが、そのプリッでは出来ませんでした。4時間も沼っていてもう疲れたのでそれ以上の探求はしませんでした。それでは並べていきましょう。

今回の沼の元#

今回、沼っていたソースコードを貼り付けます。概要としては、とあるファイルから特定のNotionのデータベースにAPIリクエストをする別のファイルに書いてあるメソッドを呼び出して（沼の元：その1）、そのメソッドが別のファイルに書いてあるクラスのメソッドを呼び出して（沼の元：その2）、そのメソッドにデコレータが付いていたわけです。（沼の元：その3）沼の元：その1です。クラスは名前空間としての役割を作るためだけに作りました。

1
class NotionDailyPropertyGenerator():
2
    def __init__(self):
3
        pass
4

5
    def retrieve_pages_on_notion_tasks(self, requests_once: bool = True, retrieves_from_cache: bool = False) -> Union[list[dict], None]:
6
        notion_model = NotionModels.TASK.value
7
        na = NotionAPI()
8
        pages = na.retrieve_pages_of_notion_db(notion_model, requests_once, retrieves_from_cache)
9
        return pages

沼の元：その2です。このクラスも名前空間としての役割を作るためだけに作りました。

1
class NotionAPI:
2
    def __init__(self):
3
        pass
4

5
    @wrap_with_debug_log
6
    def fetch_notion(self, endpoint: str, method: str, payload: dict) -> requests.Response:
7
        if endpoint is None:
8
            raise ValueError("'endpoint' must not be None.")
9
        if method is None:
10
            raise ValueError("'method' must not be None.")
11
        if payload is None:
12
            raise ValueError("'payload' must not be None.")
13
        if endpoint == "":
14
            raise ValueError("'endpoint' must not be empty.")
15
        if method == "":
16
            raise ValueError("'method' must not be empty.")
17
        if payload.__class__.__name__ != "dict":
18
            raise TypeError("'payload' must be dict type.")
19
        pprint("information to request Notion API...")
20
        pprint(endpoint)
21
        pprint(method)
22
        pprint(payload)
23

24
        headers = {
25
            "Notion-Version": "2022-06-28",
26
            "Authorization": f"Bearer {self.get_notion_integration_token()}",
27
            "Content-Type": "application/json"
28
        }
29
        pprint(f"requesting to Notion API...")
30
        if method == "GET":
31
            response = requests.request(
32
                method=method,
33
                url=endpoint,
34
                headers=headers,
35
                timeout=60
36
            )
37
        else:
38
            response = requests.request(
39
                method=method,
40
                url=endpoint,
41
                headers=headers,
42
                data=json.dumps(payload),
43
                timeout=60
44
            )
45
        if not response.ok:
46
            print(f"Error: with HTTP status code: {response.status_code} - {response.text}")
47
        response.raise_for_status()
48
        response.encoding = "utf-8"
49
        pprint(f"received response.")
50
        pprint(response.status_code)
51
        pprint(response.encoding)
52

53
        return response

沼の元：その3です。これが今回の根本の原因だったデコレータです。

1
def wrap_with_debug_log(func) -> callable:
2
    def wrapper(*args, **kwargs):
3
        # Get the caller function's name (which is now the wrapped function)
4
        func_name = func.__name__
5
        result_to_print_1 = f" with args: {args}"
6
        result_to_print_2 = f" and kwargs: {kwargs}"
7
        if len(str(args)) > 500:
8
            result_to_print_1 = " with args: ..."
9
        if len(str(kwargs)) > 500:
10
            result_to_print_2 = " and kwargs: ..."
11
        print(f"[DEBUG] {func_name}: Entering function with args: {args} and kwargs: {kwargs}")
12

13
        # Execute the wrapped function and capture the result
14
        result = func(*args, **kwargs)
15
        result_to_print_1 = f" with result: {result}"
16
        if len(str(result)) > 500:
17
            result_to_print_1 = " with result: ..."
18
        print(f"[DEBUG] {func_name}: Exiting function{result_to_print_1}")
19
        return result
20
    return wrapper

沼の元：その4です。その1のためのテストコードになります。

ディレクトリ構成はこんな感じの抜粋です。

1
my_project/
2
|
3
|
4

5
...
6

7
| |
8
|--src
9
| |
10
| |--notion_daily_property.py  # 沼の元：その1
11
| |--notion_template_page.py
12
| |--notion_util.py            # 沼の元：その2
13
| |--util.py                   # 沼の元：その3
14
|--tests
15
| |
16
| |--test_notion_daily_property.py  # 沼の元：その4
17
| |--test_notion_template_page.py
18
| |--test_notion_util.py
19
| |--test_util.py

Claudeのプリプリッ。#

Claudeがプリプリッと出した対策を並べていきます。下記のプロンプトから全てが始まりました。こちらのコードを参考にさせていただきました。

1
以下のpythonのテストコードのmockerはどう宣言すればいい？
2
---
3
*# tests/lambda_test.py (抜粋)* from lambda_function import lambda_handler def test_lambda_handler(mocker): *# インスタンス化* mock_instance = mocker.MagicMock() mocker.patch("lambda_function.ExampleClass", return_value=mock_instance) *# インスタンスメソッド* mock_instance.instance_method_example.return_value = "instance_method_2" *# クラスメソッド* mocker.patch( "lambda_function.ExampleClass.class_method_example", return_value="class_method_2", ) *# スタティックメソッド* mocker.patch( "lambda_function.ExampleClass.static_method_example", return_value="static_method_2", ) *# プロパティ* type(mock_instance).name = mocker.PropertyMock(return_value="property_2")

Claudeのプリッ：その1#

Pytestでモックを使用するためには、pytest-mockプラグインを利用する必要があります。このテストコードではmockerをテスト関数の引数として使用していますが、これを正しく動作させるためには以下の方法があります：

pytest.fixtureとしてmockerを宣言する必要はありません。pytest-mockプラグインをインストールすると、mockerフィクスチャが自動的に利用可能になります。
テストファイルの先頭に以下のインポートが必要です：

1
import pytest

テストを実行する前に、pytest-mockプラグインをインストールしておく必要があります：

1
pip install pytest-mock

完全なテストファイル例：

1
import pytest
2
from lambda_function import lambda_handler
3

4
def test_lambda_handler(mocker):
5
    # インスタンス化
6
    mock_instance = mocker.MagicMock()
7
    mocker.patch("lambda_function.ExampleClass", return_value=mock_instance)
8

9
    # インスタンスメソッド
10
    mock_instance.instance_method_example.return_value = "instance_method_2"
11

12
    # クラスメソッド
13
    mocker.patch(
14
        "lambda_function.ExampleClass.class_method_example",
15
        return_value="class_method_2",
16
    )
17

18
    # スタティックメソッド
19
    mocker.patch(
20
        "lambda_function.ExampleClass.static_method_example",
21
        return_value="static_method_2",
22
    )
23

24
    # プロパティ
25
    type(mock_instance).name = mocker.PropertyMock(return_value="property_2")
26

27
    # テスト対象の関数を呼び出し
28
    result = lambda_handler(event={}, context={})
29

30
    # アサーションをここに追加
31
    # assert result == expected_result

pytest-mockプラグインをインストールしていれば、特別な宣言なしでmocker引数を使用できます。これはpytestが自動的に提供するフィクスチャなので、別途宣言する必要はありません。なるほど、pytest-mockというパッケージをインストールしておかなければならんのか。うんまあ、入ってたからヨシ。先に進もう。

Claudeのプリッ：その2#

ダメだ。動かん。

1
テストクラスの中で使いたい。

テストクラスの中で mocker フィクスチャを使用する場合、クラスベースのテストスタイルに適した形で記述する必要があります。以下の方法があります：

1
import pytest
2

3
class TestLambdaFunction:
4
    def test_lambda_handler(self, mocker):
5
        # インスタンス化
6
        mock_instance = mocker.MagicMock()
7
        mocker.patch("lambda_function.ExampleClass", return_value=mock_instance)
8

9
        # インスタンスメソッド
10
        mock_instance.instance_method_example.return_value = "instance_method_2"
11

12
        # クラスメソッド
13
        mocker.patch(
14
            "lambda_function.ExampleClass.class_method_example",
15
            return_value="class_method_2",
16
        )
17

18
        # スタティックメソッド
19
        mocker.patch(
20
            "lambda_function.ExampleClass.static_method_example",
21
            return_value="static_method_2",
22
        )
23

24
        # プロパティ
25
        type(mock_instance).name = mocker.PropertyMock(return_value="property_2")
26

27
        # テスト対象の関数を呼び出し
28
        from lambda_function import lambda_handler
29
        result = lambda_handler(event={}, context={})
30

31
        # アサーション
32
        # assert result == expected_result

クラスベースのテストでも、テストメソッドの引数として mocker を渡すことで、pytest-mock プラグインが提供する機能をそのまま使用できます。特別な初期化や宣言は不要です。pytest がテスト実行時に自動的に mocker フィクスチャを注入します。ふむふむ、先に進もう。

Claudeのプリッ：その3#

動きません。「assert mocker.call」はモックがテスト中に呼び出されていればTrueになります。

1
モックされない。「assert mocker.call」ではアサーションエラーにならないのに。

モックが正しく機能していない問題について調査しましょう。assert mocker.callでアサーションエラーにならないというのは、通常、モックが呼び出されていないか、正しく設定されていないことを示しています。テストクラス内でモックを正しく動作させるための一般的な問題と解決策をいくつか挙げます：

pytestのスコープ問題：クラスメソッド内でのモックは、そのメソッドのスコープ内でのみ有効です。
autouse=Trueのフィクスチャを使用する：

1
import pytest
2
from unittest.mock import MagicMock, patch
3

4
class TestLambdaFunction:
5
    @pytest.fixture(autouse=True)
6
    def setup_mocks(self, mocker):
7
        # クラス全体で使えるモックをセットアップ
8
        self.mock_instance = mocker.MagicMock()
9
        self.patcher = mocker.patch("lambda_function.ExampleClass", return_value=self.mock_instance)
10

11
        # インスタンスメソッド
12
        self.mock_instance.instance_method_example.return_value = "instance_method_2"
13

14
        # クラスメソッド
15
        self.class_method_patcher = mocker.patch(
16
            "lambda_function.ExampleClass.class_method_example",
17
            return_value="class_method_2"
18
        )
19

20
        # スタティックメソッド
21
        self.static_method_patcher = mocker.patch(
22
            "lambda_function.ExampleClass.static_method_example",
23
            return_value="static_method_2"
24
        )
25

26
        # プロパティ
27
        type(self.mock_instance).name = mocker.PropertyMock(return_value="property_2")
28

29
        yield
30
        # テスト後のクリーンアップ
31
        self.patcher.stop()
32
        self.class_method_patcher.stop()
33
        self.static_method_patcher.stop()
34

35
    def test_lambda_handler(self):
36
        from lambda_function import lambda_handler
37
        result = lambda_handler(event={}, context={})
38

39
        # モックが呼ばれたことを確認
40
        assert "lambda_function.ExampleClass" in str(self.patcher.call_args_list)
41
        # または明示的に
42
        self.mock_instance.instance_method_example.assert_called_once()

importの問題: lambda_functionモジュールをテスト内でインポートする時点が重要です。モックパッチを適用した後にインポートする必要があります:

1
import pytest
2

3
class TestLambdaFunction:
4
    def test_lambda_handler(self, mocker):
5
        # パッチを適用
6
        mock_instance = mocker.MagicMock()
7
        mocker.patch("lambda_function.ExampleClass", return_value=mock_instance)
8

9
        # ここでインポート（パッチ適用後）
10
        from lambda_function import lambda_handler
11

12
        # テスト実行
13
        result = lambda_handler(event={}, context={})
14

15
        # アサーション
16
        mock_instance.instance_method_example.assert_called_once()

モジュールパスの問題: モックするパスが正確であることを確認してください。lambda_function.pyが別のディレクトリにある場合、パスを調整する必要があります。
pytest-mockのバージョン確認: 最新版のpytest-mockを使用していることを確認:

1
pip install --upgrade pytest-mock

上記の解決策を試しても問題が解決しない場合は、lambda_function.pyの内容と実際のテストコードを共有していただけると、より具体的なアドバイスができます。インポートを途中から呼び出すやつだな。やりますか。

Claudeのプリッ：その4#

またダメだ。モックが呼び出されませんでした。

1
モック出来ない。「assert "notion_util.NotionAPI" in str(self.patcher.call_args_list)」でアサーションエラーになる。

問題を解決するために、モックが正しく適用されていない原因を分析しましょう。エラーの原因として、モックのパス指定が間違っている可能性が高いです。"src.notion_util.NotionAPI" というパスでモックを適用していますが、実際のインポートパスと一致していない可能性があります。以下の解決策を試してみてください：

インポートパスの確認: モックされるべきクラスが実際にどのようにインポートされているか確認します。コードの中でどのように NotionAPI をインポートしているかを確認してください。
モックパスの修正: setup_test メソッドのモックの設定を修正します：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # 現在のパス
4
    self.mocker_for_notion_api = mocker.MagicMock()
5
    # このパスが正しいか確認
6
    self.patcher = mocker.patch("src.notion_util.NotionAPI", return_value=self.mocker_for_notion_api)
7

8
    # 他の可能性のあるパスも試してみる
9
    # self.patcher = mocker.patch("notion_util.NotionAPI", return_value=self.mocker_for_notion_api)
10
    # または
11
    # from src.notion_util import NotionAPI
12
    # self.patcher = mocker.patch.object(NotionAPI, "__new__", return_value=self.mocker_for_notion_api)
13

14
    self.mocker_for_notion_api.fetch_notion.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
15
    # ...

インポート順序の問題: モジュールのインポートがモックの設定前に行われている可能性があります。以下の方法を試してみてください：

1
def test_retrieve_pages_on_notion_tasks_01_01(self, mocker):
2
    # テスト前にモジュールを再ロードしてみる
3
    import importlib
4
    import src.notion_util
5
    importlib.reload(src.notion_util)
6

7
    # または、テスト内で明示的にインポート
8
    from src.notion_daily_property import NotionDailyPropertyGenerator
9

10
    instance = self.property_generator()
11
    notion_database_id = "mock_database_id"
12
    requests_once = True
13

14
    pages = instance.retrieve_pages_on_notion_tasks(notion_database_id, requests_once)
15

16
    # アサーション
17
    assert "NotionAPI" in str(self.patcher.call_args_list)
18
    # または
19
    self.mocker_for_notion_api.fetch_notion.assert_called_once()

モック方法の変更: クラスではなく関数として直接モックを設定する方法も試してみてください：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # 直接関数をモック
4
    self.mocker_for_notion_api = mocker.MagicMock()
5
    self.mocker_for_notion_api.fetch_notion.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
6

7
    # retrieve_pages_on_notion_tasks内で使用される関数を直接モック
8
    self.patcher = mocker.patch("src.notion_daily_property.NotionAPI", return_value=self.mocker_for_notion_api)
9
    # ...

NotionDailyPropertyGeneratorのコード確認: もし可能であれば、NotionDailyPropertyGenerator クラスの実装、特に retrieve_pages_on_notion_tasks メソッドの実装を確認して、実際に NotionAPI がどのように使われているかを見ることができれば、より具体的な解決策を提供できます。

これらの方法を試しても解決しない場合は、src.notion_daily_property モジュールのコード（特に retrieve_pages_on_notion_tasks メソッド）を確認して、NotionAPI がどのように使用されているかの詳細を教えていただければ幸いです。うーん・・・。

Claudeのプリッ：その5#

全然出来ないので、業を煮やした僕はコードを貼り付ける。

1
「self.patcher = mocker.patch.object(NotionAPI, "__new__", return_value=self.mocker_for_notion_api)」を
2
試したら、アサーションエラーにはなったが実際の値が変わった。
3
変える前は2100（モックが当たらない時に取れる実際の値）となっていたが、変えたら0になっていた。
4
NotionDailyPropertyGeneratorのコードを添付する。
5
---
6
class NotionDailyPropertyGenerator():
7
    def **init**(self):
8
        pass
9
    def get_title_of_notion_daily_report_page(self, date: Union[datetime, None]=None):
10
        """
11
        Generate the title of the Notion daily report page for a specific date.
12
        Args:
13
            date (datetime): The date to generate the title for.
14
        Returns:
15
            str: The formatted page title.
16
        """
17
        if date is None:
18
            date = get_datetime_now(is_jst=True)
19
        cfg = notion_config()
20
        prefix = cfg.DAILY_PAGE_PREFIX
21
        date_str = date.strftime("%Y-%m-%d(%a)")
22
        return f"{prefix}_{date_str}"
23
def retrieve_pages_on_notion_tasks(self, requests_once: bool = True, retrieves_from_cache: bool = False) -> Union[list[dict], None]:
24
        notion_model = "task"
25
        na = NotionAPI()
26
        pages = na.retrieve_pages_of_notion_db(notion_model, requests_once, retrieves_from_cache)
27
        return pages

問題の原因がわかりました。モックのパスに問題があったと考えられます。mocker.patch.object(NotionAPI, "__new__", return_value=self.mocker_for_notion_api) を試したときに値が変わった（2100から0になった）という結果は進展を示しています。 NotionDailyPropertyGenerator の retrieve_pages_on_notion_tasks メソッドを見ると、以下のコードがあります：

1
def retrieve_pages_on_notion_tasks(self, requests_once: bool = True, retrieves_from_cache: bool = False) -> Union[list[dict], None]:
2
    notion_model = "task"
3
    na = NotionAPI()
4
    pages = na.retrieve_pages_of_notion_db(notion_model, requests_once, retrieves_from_cache)
5
    return pages

ここで NotionAPI() をインスタンス化しています。これをモックするためには、以下のように修正してみましょう：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # モックのセットアップ
4
    self.mocker_for_notion_api = mocker.MagicMock()
5

6
    # NotionAPIをインポート
7
    from src.notion_util import NotionAPI
8

9
    # NotionAPIクラスそのものをモック
10
    self.patcher = mocker.patch("src.notion_daily_property.NotionAPI", return_value=self.mocker_for_notion_api)
11

12
    # モックの戻り値を設定
13
    self.mocker_for_notion_api.retrieve_pages_of_notion_db.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()["results"]
14

15
    # 他の設定
16
    self.magic_mock = MagicMock()
17
    self.monkey_patch = monkeypatch
18

19
    self.set_env_vars(self.get_test_data())
20
    yield
21
    # teardown
22
    self.remove_env_vars(self.get_test_data())
23
    self.patcher.stop()

変更点のポイント：

NotionAPIのパスを src.notion_daily_property.NotionAPI に変更しています。これは、retrieve_pages_on_notion_tasks メソッド内でインポートしているクラスをモックするために必要です。
モックの戻り値を retrieve_pages_of_notion_db メソッドに設定しています。コードを見ると、実際に呼び出されているメソッドは fetch_notion ではなく retrieve_pages_of_notion_db です。
戻り値として self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()["results"] を設定しています。これは実際のJSONレスポンスに合わせて、results キーの値を返すようにするためです。

これらの変更を行った後、テストを再度実行してみてください。モックが正しく適用され、assert "NotionAPI" in str(self.patcher.call_args_list) が成功するはずです。また、テストメソッド内でのアサーションも以下のように変更するとより明確になります：

1
def test_retrieve_pages_on_notion_tasks_01_01(self, mocker):
2
    instance = self.property_generator()
3
    notion_database_id = "mock_database_id"
4
    requests_once = True
5

6
    pages = instance.retrieve_pages_on_notion_tasks(notion_database_id, requests_once)
7

8
    # モックが呼ばれたことを確認
9
    self.patcher.assert_called_once()
10

11
    # retrieve_pages_of_notion_dbメソッドが呼ばれたことを確認
12
    self.mocker_for_notion_api.retrieve_pages_of_notion_db.assert_called_once_with("task", notion_database_id, requests_once)
13

14
    # 結果の確認
15
    assert len(pages) == 2

この方法でモックが正しく適用されるはずです。おいおい原因が分かったって！？　それは本当かぃぃ！？

Claudeのプリッ：その6#

ダメだ・・・。

「self.mocker_for_notion_api.fetch_notion.assert_called_once_with(“task”, notion_database_id, requests_once)」の処理で、「AssertionError: Expected ‘fetch_notion’ to be called once. Called 0 times.」というアサーションエラーが表示されました。

fetch_notion メソッドが呼ばれていないというエラーが出ていますね。これは、実際のコードで使用されているメソッド名と、モックで設定したメソッド名が一致していないことを示しています。コードを見ると、NotionDailyPropertyGenerator.retrieve_pages_on_notion_tasks メソッドでは：

1
def retrieve_pages_on_notion_tasks(self, requests_once: bool = True, retrieves_from_cache: bool = False) -> Union[list[dict], None]:
2
    notion_model = "task"
3
    na = NotionAPI()
4
    pages = na.retrieve_pages_of_notion_db(notion_model, requests_once, retrieves_from_cache)
5
    return pages

na.retrieve_pages_of_notion_db メソッドを呼び出していることがわかります。しかし、テストでは fetch_notion メソッドが呼ばれるとアサートしています。修正方法としては、以下のようにアサーションを変更してください：

1
def test_retrieve_pages_on_notion_tasks_01_01(self, mocker):
2
    instance = self.property_generator()
3
    notion_database_id = "mock_database_id"
4
    requests_once = True
5

6
    pages = instance.retrieve_pages_on_notion_tasks(requests_once)
7

8
    # モックが呼ばれたことを確認
9
    self.patcher.assert_called_once()
10

11
    # retrieve_pages_of_notion_dbメソッドが呼ばれたことを確認
12
    self.mocker_for_notion_api.retrieve_pages_of_notion_db.assert_called_once_with("task", requests_once, False)
13

14
    # 結果の確認
15
    assert len(pages) == 2

また、setup_test メソッドでのモックの設定も次のように変更してください：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # モックのセットアップ
4
    self.mocker_for_notion_api = mocker.MagicMock()
5

6
    # NotionAPIクラスをモック
7
    self.patcher = mocker.patch("src.notion_daily_property.NotionAPI", return_value=self.mocker_for_notion_api)
8

9
    # retrieve_pages_of_notion_dbメソッドの戻り値を設定
10
    self.mocker_for_notion_api.retrieve_pages_of_notion_db.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()["results"]
11

12
    # 他の設定
13
    self.magic_mock = MagicMock()
14
    self.monkey_patch = monkeypatch
15

16
    self.set_env_vars(self.get_test_data())
17
    yield
18
    # teardown
19
    self.remove_env_vars(self.get_test_data())
20
    self.patcher.stop()

重要なポイント：

fetch_notion ではなく retrieve_pages_of_notion_db メソッドをモックして戻り値を設定
アサーションも retrieve_pages_of_notion_db メソッドが呼ばれることを確認するように変更
パラメータの順序と名前を正確に合わせる（notion_model, requests_once, retrieves_from_cache）

また、オリジナルのコードでは notion_database_id を引数として渡していますが、実際のメソッド定義ではこのパラメータは使用されていないようです。そのため、テストでも notion_database_id を引数として渡さないように修正しました。ふむふむ、モックする対象を変えると来たか・・・・・・うん？

Claudeのプリッ：その7#

通った！！　・・・けど、実際に使いたい関数自体をモックしてしまっているから、全くもってテストとしての役割を果たしていない。

1
その実装でモック出来るようにはなったんですけど、テストカバレッジを上げたいです。
2
なので、fetch_notionをモックしたい。

fetch_notion をモックしたいということですね。NotionAPI クラス内の retrieve_pages_of_notion_db メソッドが内部で fetch_notion を呼び出しているのであれば、そこまで深くモックすることでカバレッジを向上させることができます。以下のようにモックを設定してみましょう：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # NotionAPIのインスタンスのモック
4
    self.mocker_for_notion_api = mocker.MagicMock()
5

6
    # NotionAPIクラス自体をモック
7
    self.patcher = mocker.patch("src.notion_daily_property.NotionAPI", return_value=self.mocker_for_notion_api)
8

9
    # fetch_notionメソッドのモック設定
10
    self.mocker_for_notion_api.fetch_notion.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
11

12
    # retrieve_pages_of_notion_dbメソッドも引き続きモック
13
    # 実際のNotionAPIクラスの実装に従って結果を返す
14
    self.mocker_for_notion_api.retrieve_pages_of_notion_db.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()["results"]
15

16
    # 他の設定
17
    self.magic_mock = MagicMock()
18
    self.monkey_patch = monkeypatch
19

20
    self.set_env_vars(self.get_test_data())
21
    yield
22
    # teardown
23
    self.remove_env_vars(self.get_test_data())
24
    self.patcher.stop()

そして、テストメソッドでは両方のメソッドが呼ばれたことを確認します：

1
def test_retrieve_pages_on_notion_tasks_01_01(self, mocker):
2
    instance = self.property_generator()
3
    requests_once = True
4

5
    pages = instance.retrieve_pages_on_notion_tasks(requests_once)
6

7
    # NotionAPIクラスがインスタンス化されたことを確認
8
    self.patcher.assert_called_once()
9

10
    # retrieve_pages_of_notion_dbメソッドが呼ばれたことを確認
11
    self.mocker_for_notion_api.retrieve_pages_of_notion_db.assert_called_once_with("task", requests_once, False)
12

13
    # 内部でfetch_notionが呼ばれたかを確認したい場合
14
    # ただし、この部分はretrieve_pages_of_notion_dbの内部実装に依存するため、
15
    # 実際の挙動に合わせて調整が必要かもしれません
16
    # self.mocker_for_notion_api.fetch_notion.assert_called()
17

18
    assert len(pages) == 2

もし NotionAPI クラスの内部実装をより深くテストしたい場合は、NotionAPIクラスそのものをモックするのではなく、そのメソッドのみをモックする方法も検討できます：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # NotionAPIのfetch_notionメソッドのみをモック
4
    self.fetch_notion_mock = mocker.patch("src.notion_util.NotionAPI.fetch_notion")
5
    self.fetch_notion_mock.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
6

7
    # 実際のretrieve_pages_of_notion_dbメソッドを実行してfetch_notionを呼び出すようにする
8

9
    # 他の設定
10
    self.magic_mock = MagicMock()
11
    self.monkey_patch = monkeypatch
12

13
    self.set_env_vars(self.get_test_data())
14
    yield
15
    # teardown
16
    self.remove_env_vars(self.get_test_data())

この方法では、NotionAPI クラス自体はモックせず、そのメソッド fetch_notion のみをモックするため、retrieve_pages_of_notion_db の実際のコードが実行され、内部で fetch_notion が呼び出されたときにモックの結果が返されます。ただし、この方法が機能するかどうかは、NotionAPI クラスの実際の実装に依存します。NotionAPI クラスのコードを確認し、retrieve_pages_of_notion_db メソッドが内部でどのように fetch_notion を呼び出しているかを把握することが重要です。よしよし、深くモックするかぁぁ・・・・・・retrieve_pages_of_notion_db？

Claudeのプリッ：その8#

だから、その実装ではテストする意味が無いのだ・・・。

1
`NotionAPI` クラスの内部実装を介した返り値をテストしたいです。その場合、以下の実装ではモック出来ませんでした。
2
---
3
@pytest.fixture(autouse=True)
4
def setup_test(self, mocker: MockFixture, monkeypatch):
5
    # NotionAPIのfetch_notionメソッドのみをモック
6
    self.fetch_notion_mock = mocker.patch("src.notion_util.NotionAPI.fetch_notion")
7
    self.fetch_notion_mock.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
8

9
    # 実際のretrieve_pages_of_notion_dbメソッドを実行してfetch_notionを呼び出すようにする
10

11
    # 他の設定
12
    self.magic_mock = MagicMock()
13
    self.monkey_patch = monkeypatch
14
    self.set_env_vars(self.get_test_data())
15
    yield
16
    # teardown
17
    self.remove_env_vars(self.get_test_data())

内部実装を介した返り値をテストする場合、インスタンス化の順序や、モックの適用先が重要になります。NotionAPI.fetch_notion をモックする場合、以下の点に注意する必要があります。まず、モックの設定方法を修正してみましょう：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # NotionAPIクラスのfetch_notionメソッドのみをモック
4
    # インポートを明示的に行う
5
    from src.notion_util import NotionAPI
6

7
    # パッチを作成する前に、モジュールをリロードして確実に最新の状態を使用
8
    import importlib
9
    import src.notion_util
10
    importlib.reload(src.notion_util)
11

12
    # fetch_notionメソッドをパッチ
13
    self.fetch_notion_mock = mocker.patch.object(NotionAPI, 'fetch_notion')
14
    self.fetch_notion_mock.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
15

16
    # 環境変数の設定
17
    self.magic_mock = MagicMock()
18
    self.monkey_patch = monkeypatch
19
    self.set_env_vars(self.get_test_data())
20
    yield
21
    # teardown
22
    self.remove_env_vars(self.get_test_data())

次に、テストメソッドを以下のように修正します：

1
def test_retrieve_pages_on_notion_tasks_01_01(self, mocker):
2
    # インポートを明示的に行う
3
    from src.notion_util import NotionAPI
4

5
    # インスタンスを生成
6
    instance = self.property_generator()
7
    requests_once = True
8

9
    # テスト実行
10
    pages = instance.retrieve_pages_on_notion_tasks(requests_once)
11

12
    # fetch_notionが呼ばれたことを確認
13
    self.fetch_notion_mock.assert_called()
14

15
    # 結果の確認
16
    assert len(pages) == 2

さらに、モジュールの依存関係により、以下のようなアプローチも試してみる価値があります： モック対象のパスを確認： NotionAPIがどこからインポートされているか確認し、正確なパスでモックします。

1
# NotionDailyPropertyGeneratorのコードをデバッグプリントして確認
2
def test_debug_imports(self):
3
    from src.notion_daily_property import NotionDailyPropertyGenerator
4
    import inspect
5
    code = inspect.getsource(NotionDailyPropertyGenerator.retrieve_pages_on_notion_tasks)
6
    print(f"コード:\n{code}")
7

8
    # 実際に使用されているNotionAPIのインポート元を確認
9
    import src.notion_util
10
    print(f"NotionAPIのパス: {src.notion_util.NotionAPI}")

強制的にモックを適用： patch.multiple を使用して、複数のパスに同時にモックを適用します。

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # 複数の可能性のあるパスに同時にモックを適用
4
    mock_data = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
5
    patcher = mocker.patch.multiple(
6
        "src.notion_util.NotionAPI",
7
        fetch_notion=mocker.MagicMock(return_value=mock_data)
8
    )
9

10
    # 別の可能性のあるパスにもモックを適用
11
    mocker.patch.multiple(
12
        "src.notion_daily_property.NotionAPI",
13
        fetch_notion=mocker.MagicMock(return_value=mock_data)
14
    )
15

16
    self.magic_mock = MagicMock()
17
    self.monkey_patch = monkeypatch
18
    self.set_env_vars(self.get_test_data())
19
    yield
20
    self.remove_env_vars(self.get_test_data())

インスタンス生成を確認： NotionAPI のコンストラクタをモックして、インスタンス生成時に特定のモックインスタンスを返すようにします。

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # モックインスタンスを作成
4
    mock_instance = MagicMock()
5
    mock_instance.fetch_notion.return_value = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
6

7
    # NotionAPIのコンストラクタをモック
8
    patcher = mocker.patch("src.notion_daily_property.NotionAPI", return_value=mock_instance)
9
    self.mock_instance = mock_instance
10

11
    # 環境変数設定
12
    self.magic_mock = MagicMock()
13
    self.monkey_patch = monkeypatch
14
    self.set_env_vars(self.get_test_data())
15
    yield
16
    self.remove_env_vars(self.get_test_data())
17
    patcher.stop()

これらの方法を順に試して、どれが実際の実装に適しているか確認してみてください。NotionAPIクラスの正確なインポートパスと使用方法を特定することが重要です。またちょっと毛色が変わったな・・・。おっ・・・？

Claudeのプ・・・なんだこれ？？#

先ほどClaude君が出してくれたinspectパッケージを使った手法ですね。このパッケージを使うとですね、ソースコードをターミナルに出力することが出来ます。そして、fetch_notionに対して実行すると、こんなコードが出てきた。

1
コード:
2
    def wrapper(*args, **kwargs):
3
        # Get the caller function's name (which is now the wrapped function)
4
        func_name = func.__name__
5
        result_to_print_1 = f" with args: {args}"
6
        result_to_print_2 = f" and kwargs: {kwargs}"
7
        if len(str(args)) > 500:
8
            result_to_print_1 = " with args: ..."
9
        if len(str(kwargs)) > 500:
10
            result_to_print_2 = " and kwargs: ..."
11
        print(f"[DEBUG] {func_name}: Entering function with args: {args} and kwargs: {kwargs}")
12

13
        # Execute the wrapped function and capture the result
14
        result = func(*args, **kwargs)
15
        result_to_print_1 = f" with result: {result}"
16
        if len(str(result)) > 500:
17
            result_to_print_1 = " with result: ..."
18
        print(f"[DEBUG] {func_name}: Exiting function{result_to_print_1}")
19
        return result
20

21
NotionAPIのパス: <class 'src.notion_util.NotionAPI'>

あああ～・・・。

Claudeのプリッ：その9#

報告します。（ちなみにフィクスチャは関数の上に付けるグルグルしたアットマークのヤツのこと。デコレータは任意の関数の前後で処理をするヤツのこと。今回はフィクスチャを使ってデコレータを呼んでいました。）

1
NotionAPI.fetch_notionメソッドは、以下の関数を呼ぶフィクスチャが付いていました。
2
---
3
def wrapper(*args, **kwargs):
4
        # Get the caller function's name (which is now the wrapped function)
5
        func_name = func.__name__
6
        result_to_print_1 = f" with args: {args}"
7
        result_to_print_2 = f" and kwargs: {kwargs}"
8
        if len(str(args)) > 500:
9
            result_to_print_1 = " with args: ..."
10
        if len(str(kwargs)) > 500:
11
            result_to_print_2 = " and kwargs: ..."
12
        print(f"[DEBUG] {func_name}: Entering function with args: {args} and kwargs: {kwargs}")
13
        # Execute the wrapped function and capture the result
14
        result = func(*args, **kwargs)
15
        result_to_print_1 = f" with result: {result}"
16
        if len(str(result)) > 500:
17
            result_to_print_1 = " with result: ..."
18
        print(f"[DEBUG] {func_name}: Exiting function{result_to_print_1}")
19
        return result

デバッグ用のラッパー関数が NotionAPI.fetch_notion メソッドに付いていることがわかりました。これはメソッドをデコレートして、呼び出し時の引数と戻り値を出力するためのものですね。このようなラッパー関数がある場合、モックの設定には追加の考慮が必要です。デコレーターを適用されたメソッドをモックする方法として、以下のアプローチを試してみましょう：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # モックデータを取得
4
    mock_data = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
5

6
    # NotionAPIをインポート
7
    from src.notion_util import NotionAPI
8

9
    # 実際のインスタンスを作成し、そのメソッドをモック
10
    # これにより、デコレーターが適用された後のメソッドをモックできる
11
    self.real_instance = NotionAPI()
12

13
    # monkeypatchを使用して、インスタンスメソッドを直接置き換え
14
    def mock_fetch_notion(*args, **kwargs):
15
        print(f"[MOCK] fetch_notion called with args: {args}, kwargs: {kwargs}")
16
        return mock_data
17

18
    # インスタンスのメソッドを直接モック
19
    monkeypatch.setattr(self.real_instance, 'fetch_notion', mock_fetch_notion)
20

21
    # NotionAPIのコンストラクタをモックして、モック済みのインスタンスを返す
22
    self.patcher = mocker.patch('src.notion_daily_property.NotionAPI', return_value=self.real_instance)
23

24
    # 環境変数の設定
25
    self.magic_mock = MagicMock()
26
    self.monkey_patch = monkeypatch
27
    self.set_env_vars(self.get_test_data())
28
    yield
29
    # teardown
30
    self.remove_env_vars(self.get_test_data())
31
    self.patcher.stop() if hasattr(self, 'patcher') else None

あるいは、デコレーターを回避してモックする方法も試してみましょう：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # モックデータを取得
4
    mock_data = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
5

6
    # モックインスタンスを作成
7
    mock_instance = mocker.MagicMock()
8

9
    # fetch_notionの戻り値を設定
10
    mock_fetch_notion = mocker.MagicMock(return_value=mock_data)
11
    mock_instance.fetch_notion = mock_fetch_notion
12

13
    # retrieve_pages_of_notion_dbの戻り値も設定
14
    mock_instance.retrieve_pages_of_notion_db.return_value = mock_data["results"]
15

16
    # NotionAPIクラスのコンストラクタをモックして、このモックインスタンスを返す
17
    self.patcher = mocker.patch('src.notion_daily_property.NotionAPI', return_value=mock_instance)
18

19
    # テスト用に参照を保持
20
    self.mock_instance = mock_instance
21
    self.mock_fetch_notion = mock_fetch_notion
22

23
    # 環境変数の設定
24
    self.magic_mock = MagicMock()
25
    self.monkey_patch = monkeypatch
26
    self.set_env_vars(self.get_test_data())
27
    yield
28
    # teardown
29
    self.remove_env_vars(self.get_test_data())
30
    self.patcher.stop() if hasattr(self, 'patcher') else None

そして、テストメソッドでは次のように確認します：

1
def test_retrieve_pages_on_notion_tasks_01_01(self, mocker):
2
    instance = self.property_generator()
3
    requests_once = True
4

5
    pages = instance.retrieve_pages_on_notion_tasks(requests_once)
6

7
    # NotionAPIがインスタンス化されたことを確認
8
    self.patcher.assert_called_once()
9

10
    # モックメソッドが呼ばれたことを確認
11
    if hasattr(self, 'mock_fetch_notion'):
12
        # 第二のアプローチの場合
13
        self.mock_fetch_notion.assert_called()
14
    else:
15
        # 第一のアプローチの場合
16
        # ここでは明示的なアサーションができないが、
17
        # デバッグ出力から呼び出しを確認できる
18
        pass
19

20
    # 結果の確認
21
    assert len(pages) == 2

デコレーターが複雑なモックの問題を引き起こしている場合、テスト専用の環境変数を設定して、デバッグ用のデコレーターを無効化するという方法も検討する価値があります。例えば、TEST_MODE=True のような環境変数を設定し、デコレーターの適用を条件付きにすることができれば、テスト時のモックがより簡単になります。よしよし、少し進展したか・・・。

Claudeのプリッ：その10#

ダメだ。デコレータを看過できない。

1
デコレーターの適用を条件付きにする方法を教えて

デコレーターの適用を条件付きにするには、デコレーターの実装時に環境変数を確認し、テスト環境では適用しないようにする方法が有効です。以下に実装例を示します。 条件付きデコレーターの実装方法

1
import os
2
import functools
3

4
def debug_decorator(func):
5
    @functools.wraps(func)
6
    def wrapper(*args, **kwargs):
7
        # 環境変数 TEST_MODE が "True" の場合はデコレーターをスキップ
8
        if os.environ.get("TEST_MODE") == "True":
9
            # テスト時は元の関数をそのまま実行
10
            return func(*args, **kwargs)
11

12
        # 通常時はデバッグログを出力
13
        func_name = func.__name__
14
        result_to_print_1 = f" with args: {args}"
15
        result_to_print_2 = f" and kwargs: {kwargs}"
16
        if len(str(args)) > 500:
17
            result_to_print_1 = " with args: ..."
18
        if len(str(kwargs)) > 500:
19
            result_to_print_2 = " and kwargs: ..."
20
        print(f"[DEBUG] {func_name}: Entering function{result_to_print_1}{result_to_print_2}")
21

22
        # 元の関数を実行して結果を取得
23
        result = func(*args, **kwargs)
24

25
        result_to_print = f" with result: {result}"
26
        if len(str(result)) > 500:
27
            result_to_print = " with result: ..."
28
        print(f"[DEBUG] {func_name}: Exiting function{result_to_print}")
29
        return result
30

31
    return wrapper

テストでの使用方法 テスト実行前に環境変数 TEST_MODE を設定します：

1
@pytest.fixture(autouse=True)
2
def setup_test(self, mocker: MockFixture, monkeypatch):
3
    # テストモードを有効にして、デコレーターをスキップ
4
    monkeypatch.setenv("TEST_MODE", "True")
5

6
    # モックの設定
7
    mock_data = self.get_test_data_for_test_retrieve_pages_on_notion_tasks_01_01()
8

9
    # ここでは元のメソッドに直接モックを設定できる
10
    self.fetch_notion_mock = mocker.patch("src.notion_util.NotionAPI.fetch_notion")
11
    self.fetch_notion_mock.return_value = mock_data
12

13
    # 残りの設定...
14
    self.set_env_vars(self.get_test_data())
15
    yield
16
    # teardown
17
    self.remove_env_vars(self.get_test_data())

すでに適用されたデコレーターがある場合 すでにコードベースにデコレーターが適用されていて変更できない場合は、テスト用の差し替えモジュールを作成する方法もあります：

テスト用のモジュールを作成（例: test_notion_util.py）
本番コードと同じクラスやメソッドを持ちますが、デコレーターなしで実装
テスト時にモジュールのインポートパスを書き換える

1
# テスト内でのモジュールパス書き換え
2
@pytest.fixture(autouse=True)
3
def setup_test(self, mocker: MockFixture, monkeypatch):
4
    # テスト用モジュールをインポートパスに挿入
5
    import sys
6
    import test_notion_util
7
    sys.modules['src.notion_util'] = test_notion_util
8

9
    # 以降のモック設定...

このアプローチはより侵襲的ですが、既存のコードを変更せずにテストを可能にします。どの方法を選ぶかは、プロジェクトの状況やテストの目的によって異なります。条件付きデコレーターの実装が最も簡単で推奨される方法です。その方法だと、既にデコレータを呼んでしまっているのでダメじゃないですか？

結局、分からなかった。#

ダメだ。こんなにも出したのに。

お疲れ様。それでは今回の反省と行こうではないか。#

あー疲れました・・・。反省します。

一部のソースを貼り漏らした。#

fetch_notion自体のソースを貼らなかったので、AIにデコレータを気付いてもらえなかったのかもしれません。ですがしかし、Cline君に最初見てもらった時は全てのファイルを見てもらった上で、デコレータの指摘は無くて見当違いの修正をされたので、シード値によって解析結果にムラがあります。しかし、ソースを全部見てもらった方が確度は上がると思います。なので、Cline君をもっと使いたかったですが如何せん金が掛かり過ぎる・・・。これはClaude DesktopをWindows上で動かしてWSLにあるファイルを見れるかどうかを試す時が来たのかもしれない。

クリーンアーキテクチャやらSOLID原則を使う。#

全く考えてなかったですからね、このNotionツールを作り始めた頃は・・・。クリーンアーキテクチャに則ったディレクトリ構成にすれば、おそらくMagicMockとかmonkeypatchとかを使わなくてもモック出来るはずです。なので、依存性逆転、依存の注入、ビジネスロジックの引数には抽象を使う。システム開発は最初が肝心ですね。ディレクトリ構成をリファクタリングするには厳しいコード量になってしまった・・・。

まとめ#

今回の内容のまとめです。

pytest-mockをインストールしてテスト関数にmocker引数を渡すと、pytest がテスト実行時に自動的に mocker フィクスチャを注入する。
inspectパッケージを使ってソースコードをターミナルに表示出来る。
そもそもプロジェクトのアーキテクチャ設計で依存を排除すれば沼らない。

本気でクリーンアーキテクチャをモノにしなければ・・・。（プリプリ言ってる場合じゃない。）

おしまい#