339 lines
12 KiB
Python
339 lines
12 KiB
Python
"""Tests for evolution Peewee models (WP-01).
|
|
|
|
Unit tests verify model structure and defaults on unsaved instances without
|
|
touching a database. Integration tests use an in-memory SQLite database to
|
|
verify table creation, FK relationships, and unique constraints.
|
|
"""
|
|
|
|
import pytest
|
|
from peewee import SqliteDatabase, IntegrityError
|
|
from playhouse.shortcuts import model_to_dict
|
|
|
|
from app.models.evolution import (
|
|
EvolutionTrack,
|
|
EvolutionCardState,
|
|
EvolutionTierBoost,
|
|
EvolutionCosmetic,
|
|
)
|
|
from app.db_engine import Rarity, Event, Cardset, MlbPlayer, Player, Team
|
|
|
|
# All models that must exist in the test database (dependency order).
|
|
_TEST_MODELS = [
|
|
Rarity,
|
|
Event,
|
|
Cardset,
|
|
MlbPlayer,
|
|
Player,
|
|
Team,
|
|
EvolutionTrack,
|
|
EvolutionCardState,
|
|
EvolutionTierBoost,
|
|
EvolutionCosmetic,
|
|
]
|
|
|
|
_test_db = SqliteDatabase(":memory:", pragmas={"foreign_keys": 1})
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def setup_test_db():
|
|
"""Bind all models to an in-memory SQLite database, create tables, and
|
|
tear them down after each test so each test starts from a clean state."""
|
|
_test_db.bind(_TEST_MODELS)
|
|
_test_db.create_tables(_TEST_MODELS)
|
|
yield _test_db
|
|
_test_db.drop_tables(list(reversed(_TEST_MODELS)), safe=True)
|
|
|
|
|
|
# ── Fixture helpers ────────────────────────────────────────────────────────
|
|
|
|
|
|
def make_rarity():
|
|
return Rarity.create(value=1, name="Common", color="#ffffff")
|
|
|
|
|
|
def make_cardset():
|
|
return Cardset.create(name="2025", description="2025 Season", total_cards=100)
|
|
|
|
|
|
def make_player(cardset, rarity):
|
|
return Player.create(
|
|
player_id=1,
|
|
p_name="Test Player",
|
|
cost=100,
|
|
image="test.png",
|
|
mlbclub="BOS",
|
|
franchise="Boston",
|
|
cardset=cardset,
|
|
set_num=1,
|
|
rarity=rarity,
|
|
pos_1="OF",
|
|
description="Test",
|
|
)
|
|
|
|
|
|
def make_team():
|
|
return Team.create(
|
|
abbrev="TEST",
|
|
sname="Test",
|
|
lname="Test Team",
|
|
gmid=123456789,
|
|
gmname="testuser",
|
|
gsheet="https://example.com",
|
|
wallet=1000,
|
|
team_value=1000,
|
|
collection_value=1000,
|
|
season=1,
|
|
)
|
|
|
|
|
|
def make_track(card_type="batter"):
|
|
return EvolutionTrack.create(
|
|
name="Batter",
|
|
card_type=card_type,
|
|
formula="pa+tb*2",
|
|
t1_threshold=37,
|
|
t2_threshold=149,
|
|
t3_threshold=448,
|
|
t4_threshold=896,
|
|
)
|
|
|
|
|
|
# ── Unit: model field validation ───────────────────────────────────────────
|
|
|
|
|
|
class TestEvolutionTrackFields:
|
|
"""model_to_dict works on unsaved EvolutionTrack instances and all fields
|
|
are accessible with the correct values."""
|
|
|
|
def test_model_to_dict_unsaved(self):
|
|
"""All EvolutionTrack fields appear in model_to_dict on an unsaved instance."""
|
|
track = EvolutionTrack(
|
|
name="Batter",
|
|
card_type="batter",
|
|
formula="pa+tb*2",
|
|
t1_threshold=37,
|
|
t2_threshold=149,
|
|
t3_threshold=448,
|
|
t4_threshold=896,
|
|
)
|
|
data = model_to_dict(track, recurse=False)
|
|
assert data["name"] == "Batter"
|
|
assert data["card_type"] == "batter"
|
|
assert data["formula"] == "pa+tb*2"
|
|
assert data["t1_threshold"] == 37
|
|
assert data["t2_threshold"] == 149
|
|
assert data["t3_threshold"] == 448
|
|
assert data["t4_threshold"] == 896
|
|
|
|
def test_all_threshold_fields_present(self):
|
|
"""EvolutionTrack exposes all four tier threshold columns."""
|
|
fields = EvolutionTrack._meta.fields
|
|
for col in ("t1_threshold", "t2_threshold", "t3_threshold", "t4_threshold"):
|
|
assert col in fields, f"Missing column: {col}"
|
|
|
|
|
|
class TestEvolutionCardStateFields:
|
|
"""model_to_dict works on unsaved EvolutionCardState instances and
|
|
default values match the spec."""
|
|
|
|
def test_model_to_dict_defaults(self):
|
|
"""Defaults: current_tier=0, current_value=0.0, fully_evolved=False,
|
|
last_evaluated_at=None."""
|
|
state = EvolutionCardState()
|
|
data = model_to_dict(state, recurse=False)
|
|
assert data["current_tier"] == 0
|
|
assert data["current_value"] == 0.0
|
|
assert data["fully_evolved"] is False
|
|
assert data["last_evaluated_at"] is None
|
|
|
|
def test_no_progress_since_field(self):
|
|
"""EvolutionCardState must not have a progress_since field (removed from spec)."""
|
|
assert "progress_since" not in EvolutionCardState._meta.fields
|
|
|
|
|
|
class TestEvolutionStubFields:
|
|
"""Phase 2 stub models are importable and respond to model_to_dict."""
|
|
|
|
def test_tier_boost_importable(self):
|
|
assert EvolutionTierBoost is not None
|
|
|
|
def test_cosmetic_importable(self):
|
|
assert EvolutionCosmetic is not None
|
|
|
|
def test_tier_boost_model_to_dict_unsaved(self):
|
|
"""model_to_dict on an unsaved EvolutionTierBoost returns a dict."""
|
|
data = model_to_dict(EvolutionTierBoost(), recurse=False)
|
|
assert isinstance(data, dict)
|
|
|
|
def test_cosmetic_model_to_dict_unsaved(self):
|
|
"""model_to_dict on an unsaved EvolutionCosmetic returns a dict."""
|
|
data = model_to_dict(EvolutionCosmetic(), recurse=False)
|
|
assert isinstance(data, dict)
|
|
|
|
|
|
# ── Unit: constraint definitions ──────────────────────────────────────────
|
|
|
|
|
|
class TestTierConstraints:
|
|
"""current_tier defaults to 0 and valid tier values (0-4) can be saved."""
|
|
|
|
def test_tier_zero_is_default(self):
|
|
"""EvolutionCardState.current_tier defaults to 0 on create."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team = make_team()
|
|
track = make_track()
|
|
state = EvolutionCardState.create(player=player, team=team, track=track)
|
|
assert state.current_tier == 0
|
|
|
|
def test_tier_four_is_valid(self):
|
|
"""Tier 4 (fully evolved cap) can be persisted without error."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team = make_team()
|
|
track = make_track()
|
|
state = EvolutionCardState.create(
|
|
player=player, team=team, track=track, current_tier=4
|
|
)
|
|
assert state.current_tier == 4
|
|
|
|
|
|
class TestUniqueConstraint:
|
|
"""Unique index on (player_id, team_id) is enforced at the DB level."""
|
|
|
|
def test_duplicate_player_team_raises(self):
|
|
"""A second EvolutionCardState for the same (player, team) raises IntegrityError,
|
|
even when a different track is used."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team = make_team()
|
|
track1 = make_track("batter")
|
|
track2 = EvolutionTrack.create(
|
|
name="SP",
|
|
card_type="sp",
|
|
formula="ip+k",
|
|
t1_threshold=10,
|
|
t2_threshold=40,
|
|
t3_threshold=120,
|
|
t4_threshold=240,
|
|
)
|
|
EvolutionCardState.create(player=player, team=team, track=track1)
|
|
with pytest.raises(IntegrityError):
|
|
EvolutionCardState.create(player=player, team=team, track=track2)
|
|
|
|
def test_same_player_different_teams_allowed(self):
|
|
"""One EvolutionCardState per team is allowed for the same player."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team1 = make_team()
|
|
team2 = Team.create(
|
|
abbrev="TM2",
|
|
sname="T2",
|
|
lname="Team Two",
|
|
gmid=987654321,
|
|
gmname="user2",
|
|
gsheet="https://example.com",
|
|
wallet=1000,
|
|
team_value=1000,
|
|
collection_value=1000,
|
|
season=1,
|
|
)
|
|
track = make_track()
|
|
EvolutionCardState.create(player=player, team=team1, track=track)
|
|
state2 = EvolutionCardState.create(player=player, team=team2, track=track)
|
|
assert state2.id is not None
|
|
|
|
|
|
# ── Integration: table creation ────────────────────────────────────────────
|
|
|
|
|
|
class TestTableCreation:
|
|
"""All four evolution tables are created in the test DB and are queryable."""
|
|
|
|
def test_evolution_track_table_exists(self):
|
|
assert EvolutionTrack.select().count() == 0
|
|
|
|
def test_evolution_card_state_table_exists(self):
|
|
assert EvolutionCardState.select().count() == 0
|
|
|
|
def test_evolution_tier_boost_table_exists(self):
|
|
assert EvolutionTierBoost.select().count() == 0
|
|
|
|
def test_evolution_cosmetic_table_exists(self):
|
|
assert EvolutionCosmetic.select().count() == 0
|
|
|
|
|
|
# ── Integration: FK enforcement ────────────────────────────────────────────
|
|
|
|
|
|
class TestFKEnforcement:
|
|
"""FK columns resolve to the correct related instances."""
|
|
|
|
def test_card_state_player_fk_resolves(self):
|
|
"""EvolutionCardState.player_id matches the Player we inserted."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team = make_team()
|
|
track = make_track()
|
|
state = EvolutionCardState.create(player=player, team=team, track=track)
|
|
fetched = EvolutionCardState.get_by_id(state.id)
|
|
assert fetched.player_id == player.player_id
|
|
|
|
def test_card_state_team_fk_resolves(self):
|
|
"""EvolutionCardState.team_id matches the Team we inserted."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team = make_team()
|
|
track = make_track()
|
|
state = EvolutionCardState.create(player=player, team=team, track=track)
|
|
fetched = EvolutionCardState.get_by_id(state.id)
|
|
assert fetched.team_id == team.id
|
|
|
|
def test_card_state_track_fk_resolves(self):
|
|
"""EvolutionCardState.track_id matches the EvolutionTrack we inserted."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team = make_team()
|
|
track = make_track()
|
|
state = EvolutionCardState.create(player=player, team=team, track=track)
|
|
fetched = EvolutionCardState.get_by_id(state.id)
|
|
assert fetched.track_id == track.id
|
|
|
|
|
|
# ── Integration: model_to_dict on saved instances ──────────────────────────
|
|
|
|
|
|
class TestModelToDictOnSaved:
|
|
"""model_to_dict() works correctly on saved instances of all four models."""
|
|
|
|
def test_evolution_track_saved(self):
|
|
"""Saved EvolutionTrack round-trips through model_to_dict correctly."""
|
|
track = make_track()
|
|
data = model_to_dict(track, recurse=False)
|
|
assert data["name"] == "Batter"
|
|
assert data["card_type"] == "batter"
|
|
assert data["formula"] == "pa+tb*2"
|
|
assert data["t1_threshold"] == 37
|
|
|
|
def test_evolution_card_state_saved(self):
|
|
"""Saved EvolutionCardState round-trips through model_to_dict correctly."""
|
|
rarity = make_rarity()
|
|
cardset = make_cardset()
|
|
player = make_player(cardset, rarity)
|
|
team = make_team()
|
|
track = make_track()
|
|
state = EvolutionCardState.create(
|
|
player=player, team=team, track=track, current_value=42.5, current_tier=2
|
|
)
|
|
data = model_to_dict(state, recurse=False)
|
|
assert data["current_value"] == 42.5
|
|
assert data["current_tier"] == 2
|
|
assert data["fully_evolved"] is False
|