Имитация исправления конечной точки unittest, который делает несколько запросов к третьей стороне

У меня есть одна конечная точка, написанная с использованием django ninja. Этот конечный пункт запускает краулер, который выполняет несколько запросов. Последовательность запросов состоит из 3 различных процедур, в зависимости от того, есть ли у краулера уже действительные учетные данные в его сессии.

Я хочу написать e2e тесты для этих 3 процедур и каждого из возможных исключений, которые могут быть подняты. Проблема в том, что в одной последовательности есть до 6 различных запросов к нескольким различным страницам с несколькими различными полезными нагрузками.

Все, что я могу придумать, - это исправлять каждый из этих запросов по отдельности для каждого теста, но это будет некрасиво. Другая моя мысль заключается в том, что я должен быть просто удовлетворен достаточным покрытием юнит-тестами отдельных компонентов контроллера краулера.

Вот упрощенный код, иллюстрирующий мою проблему

api.py

# This is what I want to test
@api.get("/data/{data_id}")
def get_data(request, data_id):

    controller = SearchController(crawler=Crawler, scraper=Scraper)
    response_data = controller.get_data(data_id)
    return api.create_response(request=request, data=response_data, status=200)

# I have 5 of these right now and more to come
@api.exception_handler(ChangePasswordError)
def password_change_error_handler(request):
    data = {
        "error": "Failed to login",
        "message": "Provider is demanding a new password be set.",
    }
    return api.create_response(request=request, data=data, status=500)

crawler.py

class Crawler(BaseAPI):

    def __init__(self, session_cookies=cookies):

        # Inherits requests session and methods
        super().__init__()
        if self.session_cookies:
            self.session.cookies = cookiejar_from_dict(session_cookies)
        else:
            self.login()

    # Each page visit in the following two methods are a unique 
    # combination of payload and request method
    def login(self):

        self.session.cookies.clear()

        splash_page = self._visit_splash_page()
        login_page = self._visit_login_page(login_page_payload)
        start_page = self._perform_login(login_payload)

        self.save_cookies()

        return start_page

    def get_service_note_page(self, data_id: str) -> dict:

        table_page = self._visit_service_table_page()
        search_results_page = self._search_for_data(search_payload)
        search_details_page = self._visit_data_details(search_details_payload)

        return search_details_page

test_endpoint.py

# Each patch would load a sample response that has been stored locally in a pickle file

class TestDataSearchEndpoint(unittest.Testcase)
    
    # 6 different patches
    @mock.patch("visit_splash_page", mock_visit_splash_page)
    ...
    @mock.patch("visit_data_details", mock_visit_splash_page)
    def test_successful_search_with_login(self):
        assert success etc ...

    @mock.patch("visit_splash_page", mock_visit_splash_page)
    ...
    @mock.patch("perform_login", mock_perform_login_change_password_res, payload)
    def test_failed_login_change_password(self):
        self.assertRaises(call_endpoint, ChangePasswordError)
        self.assertDictEquals(response.json(), sample_error)

Это грязно. В итоге у меня будет около 12 различных патчей, чтобы покрыть все случаи, и мне придется вызывать 3-6 тестов в каждом. Даже с моим покрытием юнит-тестами я чувствую необходимость запускать сервер и тестировать эту конечную точку вручную каждый раз, когда я делаю push.

Я попробовал ваш подход к тестированию:

Переделайте свой класс Crawler

class Crawler(BaseAPI):

    def __init__(self, session_cookies=cookies):
        super().__init__()
        if self.session_cookies:
            self.session.cookies = cookiejar_from_dict(session_cookies)
        else:
            self.login()

    def login(self):
        self.session.cookies.clear()
        splash_page = self._visit_splash_page()
        login_page = self._visit_login_page(login_page_payload)
        start_page = self._perform_login(login_payload)
        self.save_cookies()
        return start_page

    def get_service_note_page(self, data_id: str) -> dict:
        table_page = self._visit_service_table_page()
        search_results_page = self._search_for_data(search_payload)
        search_details_page = self._visit_data_details(search_details_payload)
        return search_details_page

    # Adding individual methods to simplify testing
    def _visit_splash_page(self):
        # logic to visit splash page
        pass

    def _visit_login_page(self, payload):
        # logic to visit login page
        pass

    def _perform_login(self, payload):
        # logic to perform login
        pass

    def _visit_service_table_page(self):
        # logic to visit service table page
        pass

    def _search_for_data(self, payload):
        # logic to search for data
        pass

    def _visit_data_details(self, payload):
        # logic to visit data details
        pass

исправление и групповой тест :

import unittest
from unittest import mock

# Define fixtures for common responses
def mock_splash_page():
    return {"status": "ok", "page": "splash"}

def mock_login_page():
    return {"status": "ok", "page": "login"}

def mock_start_page():
    return {"status": "ok", "page": "start"}

def mock_service_table_page():
    return {"status": "ok", "page": "service_table"}

def mock_search_results_page():
    return {"status": "ok", "page": "search_results"}

def mock_search_details_page():
    return {"status": "ok", "page": "search_details"}

class TestDataSearchEndpoint(unittest.TestCase):

    def setUp(self):
        # Setup common patches
        self.patcher1 = mock.patch('crawler.Crawler._visit_splash_page', mock_splash_page)
        self.patcher2 = mock.patch('crawler.Crawler._visit_login_page', mock_login_page)
        self.patcher3 = mock.patch('crawler.Crawler._perform_login', mock_start_page)
        self.patcher4 = mock.patch('crawler.Crawler._visit_service_table_page', mock_service_table_page)
        self.patcher5 = mock.patch('crawler.Crawler._search_for_data', mock_search_results_page)
        self.patcher6 = mock.patch('crawler.Crawler._visit_data_details', mock_search_details_page)

        # Start patches
        self.mock_splash_page = self.patcher1.start()
        self.mock_login_page = self.patcher2.start()
        self.mock_start_page = self.patcher3.start()
        self.mock_service_table_page = self.patcher4.start()
        self.mock_search_results_page = self.patcher5.start()
        self.mock_search_details_page = self.patcher6.start()

    def tearDown(self):
        # Stop patches
        self.patcher1.stop()
        self.patcher2.stop()
        self.patcher3.stop()
        self.patcher4.stop()
        self.patcher5.stop()
        self.patcher6.stop()

    def test_successful_search_with_login(self):
        response = self.client.get('/data/123')
        self.assertEqual(response.status_code, 200)
        self.assertIn('page', response.json())
        self.assertEqual(response.json()['page'], 'search_details')

    @mock.patch('crawler.Crawler._perform_login', side_effect=ChangePasswordError)
    def test_failed_login_change_password(self, mock_login):
        response = self.client.get('/data/123')
        self.assertEqual(response.status_code, 500)
        self.assertEqual(response.json(), {
            "error": "Failed to login",
            "message": "Provider is demanding a new password be set.",
        })

Таким образом, ваши тесты будут чистыми, уменьшится избыточность, и вы получите полное покрытие для сценариев E2E.

Вернуться на верх