python-tdd/src/apps/lyric/tests/integrated/test_models.py

import uuid
from django.contrib import auth
from django.test import TestCase
from django.utils import timezone

from apps.lyric.models import LoginToken, PaymentMethod, Token, User, Wallet


class UserModelTest(TestCase):
    def test_model_is_configured_for_django_auth(self):
        self.assertEqual(auth.get_user_model(), User)
    
    def test_user_is_valid_with_email_only(self):
        user = User(email="a@b.cde")
        user.set_unusable_password()
        user.full_clean() # should not raise

    def test_id_is_primary_key(self):
        user = User(id="123")
        self.assertEqual(user.pk, "123")

    def test_user_can_have_a_username(self):
        user = User.objects.create(email="a@b.cde")
        user.username = "stardust"
        user.save()
        self.assertEqual(User.objects.get(pk=user.pk).username, "stardust")

    def test_searchable_defaults_to_false(self):
        user = User.objects.create(email="a@b.cde")
        self.assertFalse(user.searchable)

class LoginTokenModelTest(TestCase):
    def test_links_user_with_autogen_uid(self):
        login_token1 = LoginToken.objects.create(email="a@b.cde")
        login_token2 = LoginToken.objects.create(email="v@w.xyz")
        self.assertNotEqual(login_token1.pk, login_token2.pk)
        self.assertIsInstance(login_token1.pk, uuid.UUID)

class UserManagerTest(TestCase):
    def test_create_superuser_sets_is_staff_and_is_superuser(self):
        user = User.objects.create_superuser(
            email="admin@example.com",
            password="correct-password",
        )
        self.assertTrue(user.is_staff)
        self.assertTrue(user.is_superuser)

    def test_create_superuser_sets_usable_password(self):
        user = User.objects.create_superuser(
            email="admin@example.com",
            password="correct-password",
        )
        self.assertTrue(user.check_password("correct-password"))

class UserPaletteTest(TestCase):
    def test_palette_field_defaults_to_palette_default(self):
        user = User.objects.create(email="a@b.cde")
        self.assertEqual(user.palette, "palette-default")

class WalletCreationTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="capman@test.io")

    def test_wallet_is_created_for_new_user(self):
        self.assertTrue(Wallet.objects.filter(user=self.user).exists())
    
    def test_new_wallet_has_144_writs(self):
        wallet = Wallet.objects.get(user = self.user)
        self.assertEqual(wallet.writs, 144)

    def test_new_wallet_has_0_esteem(self):
        wallet = Wallet.objects.get(user=self.user)
        self.assertEqual(wallet.esteem, 0)

class TokenCreationTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="capman@test.io")

    def test_coin_on_a_string_created_for_new_user(self):
        self.assertTrue(
            Token.objects.filter(user=self.user, token_type=Token.COIN).exists()
        )

    def test_free_token_created_for_new_user(self):
        self.assertTrue(
            Token.objects.filter(user=self.user, token_type=Token.FREE).exists()
        )

    def test_coin_on_a_string_has_no_expiry(self):
        coin = Token.objects.get(user=self.user, token_type=Token.COIN)
        self.assertIsNone(coin.expires_at)

    def test_free_token_has_expiry_within_7_days(self):
        free = Token.objects.get(user=self.user, token_type=Token.FREE)
        self.assertIsNotNone(free.expires_at)
        delta = free.expires_at - timezone.now()
        self.assertLessEqual(delta.days, 7)
        self.assertGreater(delta.total_seconds(), 0)


class WalletTooltipTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="wallet@test.io")
        self.wallet = Wallet.objects.get(user=self.user)

    def test_tooltip_name(self):
        self.assertEqual(self.wallet.tooltip_name(), "Wallet")

    def test_tooltip_description(self):
        self.wallet.writs = 144
        self.wallet.esteem = 12
        self.assertEqual(self.wallet.tooltip_description(), "144 writs · 12 esteem")

    def test_tooltip_shoptalk_returns_none(self):
        self.assertIsNone(self.wallet.tooltip_shoptalk())

    def test_tooltip_expiry_returns_none(self):
        self.assertIsNone(self.wallet.tooltip_expiry())

    def test_tooltip_text(self):
        self.assertEqual(self.wallet.tooltip_text(), "Wallet: 144 writs · 0 esteem")


class TokenTooltipTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="tokens@test.io")

    def test_tithe_tooltip_description(self):
        tithe = Token.objects.create(user=self.user, token_type=Token.TITHE)
        self.assertEqual(tithe.tooltip_description(), "+ Writ bonus")

    def test_tooltip_description_empty_fallback(self):
        # token_type other than COIN/FREE/TITHE hits the bare return ""
        token = Token(user=self.user, token_type="")
        self.assertEqual(token.tooltip_description(), "")

    def test_tooltip_expiry_empty_when_no_expiry_and_not_coin(self):
        free = Token.objects.get(user=self.user, token_type=Token.FREE)
        free.expires_at = None
        self.assertEqual(free.tooltip_expiry(), "")

    def test_tooltip_shoptalk_none_for_non_coin(self):
        free = Token.objects.get(user=self.user, token_type=Token.FREE)
        self.assertIsNone(free.tooltip_shoptalk())

    def test_tooltip_room_html_returns_empty_when_no_room(self):
        token = Token.objects.get(user=self.user, token_type=Token.COIN)
        self.assertEqual(token.tooltip_room_html(), "")


class PaymentMethodTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(email="pay@test.io")

    def test_str(self):
        pm = PaymentMethod(user=self.user, stripe_pm_id="pm_123", last4="4242", brand="Visa")
        self.assertEqual(str(pm), "Visa ....4242")