Mocks و Fixtures

Mocks و Fixtures — Mocks & Fixtures

كودك في الواقع لا يعيش وحيداً. يتصل بقواعد بيانات، يُرسل طلبات HTTP، يقرأ ملفات، يستخدم ساعة النظام. هذه التبعيات الخارجية (External Dependencies) تُصعّب الاختبار: الشبكة قد تكون بطيئة أو غير متاحة، قاعدة البيانات تحتاج إعداداً، والوقت الحقيقي يُصعّل اختبار الكود الزمني.

الحل: الاستبدال المؤقت (Mocking). في وقت الاختبار، تستبدل الجزء الخارجي بكائن تحكم فيه أنت — يتصرف كما تريد ويُخبرك كيف استُدعي.

ما هو Mock؟

Mock هو كائن يُحاكي سلوك كائن حقيقي. يمكنه:

إرجاع قيمة مُحددة عند استدعائه
رفع استثناء عند استدعائه
تسجيل كيف استُدعي (عدد المرات، بأي معاملات)

المكتبة المعيارية توفّر unittest.mock — لا تثبيت مطلوب.

MagicMock — الكائن الذكي

MagicMock هو الأداة الرئيسية. يقبل أي استدعاء ويُعيد MagicMock آخر — يمكنك برمجة ما يُرجعه:

main.go

from unittest.mock import MagicMock

# إنشاء mock — Create a mock object
mock_service = MagicMock()

# برمجة القيمة المُرجعة — Program return value
mock_service.get_price.return_value = 150

# استدعاء الدالة — Call the function
price = mock_service.get_price("تفاح")
print(f"السعر: {price}")   # 150

# تحقق من الاستدعاء — Verify the call
print(mock_service.get_price.called)          # True
print(mock_service.get_price.call_count)      # 1
print(mock_service.get_price.call_args)       # call('تفاح')

# استدعاء ثانٍ — Second call
mock_service.get_price("خبز")
print(mock_service.get_price.call_count)      # 2

# التحقق من آخر استدعاء — Verify last call
mock_service.get_price.assert_called_with("خبز")

# التحقق من أي استدعاء سابق — Verify any call
mock_service.get_price.assert_any_call("تفاح")

print("\nالمثال يعمل!")

Output:

كيف يُساعد Mock في الاختبار

تخيّل دالة تحسب إجمالي الطلب وتُرسل إشعاراً بالبريد الإلكتروني. عند الاختبار، لا نريد إرسال بريد حقيقي — نريد فقط التحقق من أن الدالة طلبت إرسال البريد بالمعاملات الصحيحة.

main.go

import unittest
from unittest.mock import MagicMock, patch

# الكود المُختبَر — Code under test
class OrderProcessor:
    def __init__(self, email_service, inventory_service):
        # نقبل التبعيات كمعاملات — Accept dependencies as parameters
        self.email = email_service
        self.inventory = inventory_service

    def process_order(self, order):
        # تحقق من التوفر — Check availability
        if not self.inventory.is_available(order["product"], order["quantity"]):
            return {"status": "فشل", "reason": "غير متوفر"}

        # احسب الإجمالي — Calculate total
        price = self.inventory.get_price(order["product"])
        total = price * order["quantity"]

        # أرسل تأكيداً — Send confirmation
        self.email.send(
            to=order["customer_email"],
            subject="تأكيد طلبك",
            body=f"إجمالي طلبك: {total} ريال"
        )

        return {"status": "نجح", "total": total}


class TestOrderProcessor(unittest.TestCase):

    def setUp(self):
        # أنشئ mock للخدمتين — Create mocks for both services
        self.mock_email = MagicMock()
        self.mock_inventory = MagicMock()
        self.processor = OrderProcessor(self.mock_email, self.mock_inventory)

    def test_successful_order(self):
        # برمجة الـ mocks — Program the mocks
        self.mock_inventory.is_available.return_value = True
        self.mock_inventory.get_price.return_value = 50

        order = {
            "product": "كتاب Python",
            "quantity": 2,
            "customer_email": "test@example.com"
        }

        result = self.processor.process_order(order)

        # تحقق من النتيجة — Verify result
        self.assertEqual(result["status"], "نجح")
        self.assertEqual(result["total"], 100)

        # تحقق من أن البريد أُرسل — Verify email was sent
        self.mock_email.send.assert_called_once()

        # تحقق من المعاملات — Verify parameters
        call_kwargs = self.mock_email.send.call_args.kwargs
        self.assertEqual(call_kwargs["to"], "test@example.com")

    def test_out_of_stock(self):
        # منتج غير متوفر — Product not available
        self.mock_inventory.is_available.return_value = False

        order = {
            "product": "كتاب نادر",
            "quantity": 1,
            "customer_email": "test@example.com"
        }

        result = self.processor.process_order(order)

        self.assertEqual(result["status"], "فشل")
        # تأكد أن البريد لم يُرسل — Verify email was NOT sent
        self.mock_email.send.assert_not_called()


unittest.main(argv=['ignored'], exit=False, verbosity=2)

Output:

patch — استبدال التبعيات المدمجة

أحياناً لا تستطيع تمرير التبعية كمعامل — الكود يستورد الوحدة مباشرة. patch يستبدل الاسم مؤقتاً في وقت الاختبار:

# الكود الأصلي — original code
import requests

def get_user_data(user_id):
    response = requests.get(f"https://api.example.com/users/{user_id}")
    return response.json()

في الاختبار نستبدل requests.get بـ mock:

main.go

import unittest
from unittest.mock import patch, MagicMock

# محاكاة وحدة خارجية — Simulated external module
class FakeRequests:
    @staticmethod
    def get(url):
        mock_response = MagicMock()
        mock_response.json.return_value = {"id": 1, "name": "أحمد"}
        mock_response.status_code = 200
        return mock_response

# الدالة المُختبَرة (تستخدم requests) — Function under test
def fetch_user(user_id, http_client):
    # في الكود الحقيقي: response = requests.get(url)
    response = http_client.get(f"https://api.example.com/users/{user_id}")
    if response.status_code == 200:
        return response.json()
    return None


class TestFetchUser(unittest.TestCase):

    def test_successful_fetch(self):
        # استخدم FakeRequests بدل requests الحقيقي
        mock_client = FakeRequests()
        result = fetch_user(1, mock_client)

        self.assertIsNotNone(result)
        self.assertEqual(result["name"], "أحمد")

    def test_fetch_with_mock(self):
        # استخدم MagicMock لمزيد من التحكم
        mock_client = MagicMock()
        mock_response = MagicMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"id": 42, "name": "فاطمة"}
        mock_client.get.return_value = mock_response

        result = fetch_user(42, mock_client)

        self.assertEqual(result["id"], 42)
        self.assertEqual(result["name"], "فاطمة")
        # تحقق أن get استُدعيت بالـ URL الصحيح
        mock_client.get.assert_called_once_with(
            "https://api.example.com/users/42"
        )

    def test_failed_request(self):
        # محاكاة فشل الطلب — Simulate failed request
        mock_client = MagicMock()
        mock_response = MagicMock()
        mock_response.status_code = 404
        mock_client.get.return_value = mock_response

        result = fetch_user(999, mock_client)
        self.assertIsNone(result)


unittest.main(argv=['ignored'], exit=False, verbosity=2)

Output:

side_effect — سلوك ديناميكي

بدل return_value الثابت، side_effect يُشغّل دالة أو يرفع استثناء:

main.go

import unittest
from unittest.mock import MagicMock

class TestSideEffect(unittest.TestCase):

    def test_mock_raises_exception(self):
        mock_db = MagicMock()
        # اجعل الـ mock يرفع استثناء — Make mock raise exception
        mock_db.connect.side_effect = ConnectionError("قاعدة البيانات غير متاحة")

        with self.assertRaises(ConnectionError):
            mock_db.connect()

    def test_mock_returns_sequence(self):
        mock_sensor = MagicMock()
        # أرجع قيماً مختلفة في كل استدعاء — Return different values each call
        mock_sensor.read.side_effect = [10, 20, 30, 40]

        readings = [mock_sensor.read() for _ in range(4)]
        self.assertEqual(readings, [10, 20, 30, 40])

    def test_mock_dynamic_behavior(self):
        mock_translate = MagicMock()

        # دالة تُحاكي الترجمة — Function that simulates translation
        def fake_translate(text, lang):
            if lang == "en":
                return f"[EN] {text}"
            return f"[AR] {text}"

        mock_translate.side_effect = fake_translate

        result_en = mock_translate("مرحبا", "en")
        result_ar = mock_translate("Hello", "ar")

        self.assertEqual(result_en, "[EN] مرحبا")
        self.assertEqual(result_ar, "[AR] Hello")


unittest.main(argv=['ignored'], exit=False, verbosity=2)

Output:

Fixtures في pytest — مراجعة مع مثال كامل

في pytest، الـ fixture يُنشئ مورداً ويُمرّره للاختبار تلقائياً. المثال التالي يوضح كيفية تنفيذه باستخدام unittest.setUp الذي يؤدي نفس الدور:

# أسلوب pytest — pytest style
@pytest.fixture
def user_service():
    service = UserService(db=FakeDatabase())
    yield service
    service.cleanup()

def test_create_user(user_service):
    user = user_service.create("أحمد", "[email protected]")
    assert user.id is not None

المكافئ بـunittest:

# أسلوب unittest — unittest style
class TestUserService(unittest.TestCase):
    def setUp(self):
        self.service = UserService(db=FakeDatabase())

    def tearDown(self):
        self.service.cleanup()

    def test_create_user(self):
        user = self.service.create("أحمد", "[email protected]")
        self.assertIsNotNone(user.id)

متى تستخدم Mock ومتى لا؟

استخدم Mock عندما:

الكود يتصل بشبكة أو قاعدة بيانات خارجية
التبعية بطيئة (API خارجي)
تريد محاكاة حالات خطأ صعبة (انقطاع الشبكة)
التبعية تُغيّر حالة خارجية (إرسال بريد، SMS)
الكود يعتمد على الوقت الحالي (datetime.now())

لا تستخدم Mock عندما:

التبعية بسيطة ومتوفرة (دالة رياضية، معالجة نصوص)
Mock يُصعّل الاختبار أكثر مما يُبسّطه
تريد اختبار التكامل الفعلي بين المكونات

# لا داعي لـ Mock هنا — No need for mock
def test_add():
    assert add(2, 3) == 5  # دالة بسيطة لا تبعيات

# Mock منطقي هنا — Mock makes sense
def test_send_order_notification():
    mock_email = MagicMock()
    # نختبر منطق الإشعار دون إرسال بريد حقيقي

تحدي — Challenge

import unittest
import io
from unittest.mock import MagicMock

class PaymentProcessor:
    def __init__(self, gateway, logger):
        # بوابة الدفع والـ logger — Payment gateway and logger
        self.gateway = gateway
        self.logger = logger

    def charge(self, amount, card_token):
        # سجّل المحاولة — Log the attempt
        self.logger.info(f"محاولة شحن {amount}")
        result = self.gateway.charge(card_token, amount)
        if result["success"]:
            return {"status": "نجح", "transaction_id": result["id"]}
        return {"status": "رُفض", "reason": result["reason"]}


class TestPaymentProcessor(unittest.TestCase):

    def setUp(self):
        self.mock_gateway = MagicMock()
        self.mock_logger = MagicMock()
        self.processor = PaymentProcessor(self.mock_gateway, self.mock_logger)

    def test_payment_success(self):
        # برمجة استجابة ناجحة — Program successful response
        self.mock_gateway.charge.return_value = {"success": True, "id": "txn_123"}
        result = self.processor.charge(100, "tok_abc")
        # اكتب assertion للحالة الناجحة — write assertion for success case
        pass

    def test_payment_declined(self):
        # برمجة استجابة مرفوضة — Program declined response
        self.mock_gateway.charge.return_value = {"success": False, "reason": "رصيد غير كافٍ"}
        result = self.processor.charge(500, "tok_xyz")
        # اكتب assertion للحالة المرفوضة — write assertion for declined case
        pass

    def test_payment_logs_attempt(self):
        self.mock_gateway.charge.return_value = {"success": True, "id": "txn_999"}
        self.processor.charge(200, "tok_def")
        # تحقق أن logger.info استُدعيت — verify logger.info was called
        pass


test_names = ["test_payment_success", "test_payment_declined", "test_payment_logs_attempt"]
passed = 0
for name in test_names:
    t = TestPaymentProcessor(name)
    buf = io.StringIO()
    runner = unittest.TextTestRunner(stream=buf, verbosity=0)
    res = runner.run(t)
    status = "PASS" if res.wasSuccessful() else "FAIL"
    if status == "PASS":
        passed += 1
    print(f"{name}: {status}")
print(f"نجحت: {passed}/3")