python-fun/tests/test_classified_ad.py

from decimal import Decimal
from uuid import uuid4

import pytest

from domain.marketplace.classified_ad import ClassifiedAd
from domain.marketplace.classified_ad_id import ClassifiedAdId
from domain.marketplace.classified_ad_state import ClassifiedAdState
from domain.marketplace.classified_ad_text import ClassifiedAdText
from domain.marketplace.classified_ad_title import ClassifiedAdTitle
from domain.marketplace.invalid_entity_state_exception import (
    InvalidEntityStateException,
)
from domain.marketplace.price import Price
from domain.marketplace.user_id import UserId


def test_classified_ad_creation():
    ad_id = ClassifiedAdId(value=uuid4())
    owner_id = UserId(value=uuid4())

    ad = ClassifiedAd(
        id=ad_id,
        _ownerId=owner_id,
        title=ClassifiedAdTitle(title="Test Title"),
        text=ClassifiedAdText(text="Test text content"),
        price=Price(amount=Decimal("99.99")),
    )

    assert ad.id == ad_id
    assert ad._ownerId == owner_id
    assert ad.title == ClassifiedAdTitle(title="Test Title")
    assert ad.text == ClassifiedAdText(text="Test text content")
    assert ad.price == Price(amount=Decimal("99.99"))


def test_classified_ad_can_not_be_created_without_id():
    with pytest.raises(TypeError):
        ClassifiedAd(
            _ownerId=UserId(value=uuid4()),
            title=ClassifiedAdTitle(title="Title"),
            text=ClassifiedAdText(text="Text"),
            price=Price(amount=Decimal("10.00")),
        )


def test_classified_ad_can_not_be_created_without_owner_id():
    with pytest.raises(TypeError):
        ClassifiedAd(
            id=ClassifiedAdId(value=uuid4()),
            title=ClassifiedAdTitle(title="Title"),
            text=ClassifiedAdText(text="Text"),
            price=Price(amount=Decimal("10.00")),
        )


def test_classified_ad_can_be_created_without_price():
    ad_id = ClassifiedAdId(value=uuid4())
    owner_id = UserId(value=uuid4())

    ad = ClassifiedAd(
        id=ad_id,
        _ownerId=owner_id,
        title=ClassifiedAdTitle(title="Test Title"),
        text=ClassifiedAdText(text="Test text content"),
    )

    assert ad.id == ad_id
    assert ad._ownerId == owner_id
    assert ad.title == ClassifiedAdTitle(title="Test Title")
    assert ad.text == ClassifiedAdText(text="Test text content")
    assert ad.price == Price(amount=Decimal("0.00"))


def test_classified_ad_can_not_have_negative_price():
    with pytest.raises(ValueError):
        ClassifiedAd(
            id=ClassifiedAdId(value=uuid4()),
            _ownerId=UserId(value=uuid4()),
            title=ClassifiedAdTitle(title="Title"),
            text=ClassifiedAdText(text="Text"),
            price=Price(amount=Decimal("-10.00")),
        )


def test_classified_ad_is_immutable():
    ad = ClassifiedAd(
        id=ClassifiedAdId(value=uuid4()),
        _ownerId=UserId(value=uuid4()),
        title=ClassifiedAdTitle(title="Title"),
        text=ClassifiedAdText(text="Text"),
        price=Price(amount=Decimal("10.00")),
    )

    try:
        ad.title = "New Title"  # type: ignore
        assert False, "Should have raised FrozenInstanceError"
    except AttributeError:
        pass


def test_classified_ad_equality():
    ad_id = ClassifiedAdId(value=uuid4())
    owner_id = UserId(value=uuid4())

    ad1 = ClassifiedAd(
        id=ad_id,
        _ownerId=owner_id,
        title=ClassifiedAdTitle(title="Title"),
        text=ClassifiedAdText(text="Text"),
        price=Price(amount=Decimal("10.00")),
    )
    ad2 = ClassifiedAd(
        id=ad_id,
        _ownerId=owner_id,
        title=ClassifiedAdTitle(title="Title"),
        text=ClassifiedAdText(text="Text"),
        price=Price(amount=Decimal("10.00")),
    )

    assert ad1 == ad2


def test_classified_ad_title_validation():
    long_title = "a" * 101
    with pytest.raises(ValueError):
        ClassifiedAd(
            id=ClassifiedAdId(value=uuid4()),
            _ownerId=UserId(value=uuid4()),
            title=ClassifiedAdTitle(title=long_title),
            text=ClassifiedAdText(text="Text"),
            price=Price(amount=Decimal("10.00")),
        )


def test_request_to_publish_sets_state_to_pending_review():
    ad = ClassifiedAd(
        id=ClassifiedAdId(value=uuid4()),
        _ownerId=UserId(value=uuid4()),
        title=ClassifiedAdTitle(title="Title"),
        text=ClassifiedAdText(text="Text"),
        price=Price(amount=Decimal("10.00")),
    )

    published = ad.request_to_publish()

    assert published.state == ClassifiedAdState.PendingReview


def test_request_to_publish_fails_when_title_empty():
    ad = ClassifiedAd(
        id=ClassifiedAdId(value=uuid4()),
        _ownerId=UserId(value=uuid4()),
        title=ClassifiedAdTitle(title=""),
        text=ClassifiedAdText(text="Text"),
        price=Price(amount=Decimal("10.00")),
    )

    with pytest.raises(InvalidEntityStateException) as exc_info:
        ad.request_to_publish()

    assert "title" in str(exc_info.value)


def test_request_to_publish_fails_when_text_empty():
    ad = ClassifiedAd(
        id=ClassifiedAdId(value=uuid4()),
        _ownerId=UserId(value=uuid4()),
        title=ClassifiedAdTitle(title="Title"),
        text=ClassifiedAdText(text=""),
        price=Price(amount=Decimal("10.00")),
    )

    with pytest.raises(InvalidEntityStateException) as exc_info:
        ad.request_to_publish()

    assert "text" in str(exc_info.value)


def test_request_to_publish_fails_when_price_is_zero():
    ad = ClassifiedAd(
        id=ClassifiedAdId(value=uuid4()),
        _ownerId=UserId(value=uuid4()),
        title=ClassifiedAdTitle(title="Title"),
        text=ClassifiedAdText(text="Text"),
    )

    with pytest.raises(InvalidEntityStateException) as exc_info:
        ad.request_to_publish()

    assert "price" in str(exc_info.value)


def test_request_to_publish_reports_all_errors():
    ad = ClassifiedAd(
        id=ClassifiedAdId(value=uuid4()),
        _ownerId=UserId(value=uuid4()),
        title=ClassifiedAdTitle(title=""),
        text=ClassifiedAdText(text=""),
    )

    with pytest.raises(InvalidEntityStateException) as exc_info:
        ad.request_to_publish()

    assert "title" in str(exc_info.value)
    assert "text" in str(exc_info.value)
    assert "price" in str(exc_info.value)


def test_request_to_publish_does_not_mutate_original():
    ad = ClassifiedAd(
        id=ClassifiedAdId(value=uuid4()),
        _ownerId=UserId(value=uuid4()),
        title=ClassifiedAdTitle(title="Title"),
        text=ClassifiedAdText(text="Text"),
        price=Price(amount=Decimal("10.00")),
    )

    ad.request_to_publish()

    assert ad.state is None