Python unittest
Style Guide

def test_apply_discount_reduces_price_by_percentage(self):
    # Arrange
    product = Product(name="Widget", price=100.0)
    discount = Discount(percentage=20)

    # Act
    result = discount.apply(product)

    # Assert
    self.assertEqual(result.price, 80.0)

self.assertEqual(
    response.status_code, 200,
    msg=f"Expected 200 OK but got {response.status_code}: {response.text}"
)

class NotificationService:
    def __init__(self, mailer: Mailer) -> None:
        self.mailer = mailer

# In test setUp — just pass the mock in
self.mock_mailer = Mailer(MagicMock())   # real type, mocked internals
self.service = NotificationService(mailer=self.mock_mailer)

class TestUserAuth(unittest.TestCase):

    class WhenCredentialsAreValid(unittest.TestCase):
        def test_returns_auth_token(self): ...
        def test_logs_successful_login(self): ...

    class WhenPasswordIsWrong(unittest.TestCase):
        def test_raises_auth_error(self): ...
        def test_increments_failed_attempts(self): ...

import unittest
from myapp.services.user_service import UserService

class TestUserService(unittest.TestCase):

    def setUp(self) -> None:
        self.service = UserService()

    def test_get_user_by_id_returns_user(self) -> None:
        result = self.service.get_user(1)
        self.assertIsNotNone(result)

def setUp(self) -> None:
    # MagicMock() satisfies Transport — MqttClient stays a real typed object
    self.mqtt_client = MqttClient(MagicMock())

    self.service = TelemetryService(mqtt=self.mqtt_client)

def setUp(self) -> None:
    # Real typed object — MagicMock() satisfies the 2nd-level Transport dep
    self.mqtt_client = MqttClient(MagicMock())

    self.service = TelemetryService(mqtt=self.mqtt_client)

def test_connect_calls_mqtt_connect(self) -> None:
    # Arrange — replace only the method this test asserts
    self.mqtt_client.connect = MagicMock()

    # Act
    self.service.connect()

    # Assert
    self.mqtt_client.connect.assert_called_once()


def test_send_telemetry_publishes_correct_topic(self) -> None:
    # Arrange — different method, same object
    self.mqtt_client.publish = MagicMock()

    # Act
    self.service.send_telemetry("temp", "42.0")

    # Assert
    self.mqtt_client.publish.assert_called_once_with(
        topic="sensors/temp", payload="42.0"
    )

import unittest
from unittest.mock import MagicMock, patch

from myapp.mqtt.client import MqttClient        # 1st-level dep
from myapp.telemetry.service import TelemetryService


                                              # ① subclass TestCase
class TestTelemetryService(unittest.TestCase):

    def setUp(self) -> None:
        # ② Pattern A — real typed MqttClient,
        #   MagicMock() satisfies its 2nd-level Transport dep
        self.mqtt_client = MqttClient(MagicMock())

        # ③ Inject the typed object — no patching needed
        self.service = TelemetryService(mqtt=self.mqtt_client)

    # ────────────────────────────────────────────────────────────────

    def test_connect_calls_mqtt_connect(self) -> None:
        # ④ Pattern B — replace only the method this test asserts
        self.mqtt_client.connect = MagicMock()       # Arrange

        self.service.connect()                       # Act

        self.mqtt_client.connect.assert_called_once() # Assert

    # ────────────────────────────────────────────────────────────────

    def test_send_telemetry_publishes_to_correct_topic(self) -> None:
        # ④ Different method — same pattern, stays in this test
        self.mqtt_client.publish = MagicMock()       # Arrange

        self.service.send_telemetry("temp", "42.0") # Act

        self.mqtt_client.publish.assert_called_once_with(  # Assert
            topic="sensors/temp",
            payload="42.0",
        )

    # ────────────────────────────────────────────────────────────────

    def test_connect_without_broker_raises_connection_error(self) -> None:
        # ⑤ patch.object — only because MqttClient.connect
        #   internally creates the socket; can't inject it
        with patch.object(                           # Arrange
            MqttClient,
            MqttClient.connect.__name__,           # ⑥ no string literal
            side_effect=ConnectionError("unreachable"),
        ):
            with self.assertRaises(ConnectionError): # Assert wraps Act
                self.service.connect()               # Act


if __name__ == "__main__":
    unittest.main()

def test_validate_email_accepts_valid_addresses(self) -> None:
    valid_cases = [
        ("simple",    "user@example.com"),
        ("subdomain", "user@mail.example.com"),
        ("plus-tag",  "user+tag@example.com"),
    ]
    for label, email in valid_cases:
        with self.subTest(case=label, email=email):
            self.assertTrue(validate_email(email))

def test_validate_email_rejects_invalid_addresses(self) -> None:
    invalid_cases = [
        ("no-at",    "userexample.com"),
        ("empty",    ""),
        ("no-domain", "user@"),
    ]
    for label, email in invalid_cases:
        with self.subTest(case=label, email=email):
            self.assertFalse(validate_email(email))

from parameterized import parameterized

class TestEmailValidator(unittest.TestCase):

    @parameterized.expand([
        ("simple_address",  "user@example.com",       True),
        ("subdomain",       "user@mail.example.com",   True),
        ("plus_tag",        "user+tag@example.com",    True),
        ("no_at_sign",      "userexample.com",         False),
        ("empty_string",    "",                         False),
        ("no_domain",       "user@",                   False),
    ])
    def test_validate_email(self, _name: str, email: str, expected: bool) -> None:
        self.assertEqual(validate_email(email), expected)