0a17745389
Standardize formatting with black and apply ruff auto-fixes. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
195 lines
8.7 KiB
Python
195 lines
8.7 KiB
Python
"""
|
|
Tests for rarity cost adjustment logic.
|
|
|
|
This test verifies that calculate_rarity_cost_adjustment() correctly:
|
|
1. Adjusts costs when rarity changes
|
|
2. Enforces minimum costs where specified
|
|
3. Handles all rarity transitions (1-5, 99)
|
|
4. Returns original cost when rarity doesn't change
|
|
"""
|
|
|
|
from creation_helpers import calculate_rarity_cost_adjustment
|
|
|
|
|
|
class TestRarityCostAdjustments:
|
|
"""Test suite for rarity cost adjustment calculations."""
|
|
|
|
def test_no_change_same_rarity(self):
|
|
"""Cost should not change if rarity stays the same."""
|
|
assert calculate_rarity_cost_adjustment(1, 1, 1000) == 1000
|
|
assert calculate_rarity_cost_adjustment(5, 5, 50) == 50
|
|
assert calculate_rarity_cost_adjustment(99, 99, 2400) == 2400
|
|
|
|
def test_diamond_to_gold(self):
|
|
"""Diamond (1) to Gold (2): -540, min 100."""
|
|
assert calculate_rarity_cost_adjustment(1, 2, 1000) == 460
|
|
assert calculate_rarity_cost_adjustment(1, 2, 500) == 100 # min enforced
|
|
assert calculate_rarity_cost_adjustment(1, 2, 50) == 100 # min enforced
|
|
|
|
def test_diamond_to_silver(self):
|
|
"""Diamond (1) to Silver (3): -720, min 50."""
|
|
assert calculate_rarity_cost_adjustment(1, 3, 1000) == 280
|
|
assert calculate_rarity_cost_adjustment(1, 3, 500) == 50 # min enforced
|
|
assert calculate_rarity_cost_adjustment(1, 3, 100) == 50 # min enforced
|
|
|
|
def test_diamond_to_bronze(self):
|
|
"""Diamond (1) to Bronze (4): -780, min 15."""
|
|
assert calculate_rarity_cost_adjustment(1, 4, 1000) == 220
|
|
assert calculate_rarity_cost_adjustment(1, 4, 500) == 15 # min enforced
|
|
assert calculate_rarity_cost_adjustment(1, 4, 50) == 15 # min enforced
|
|
|
|
def test_diamond_to_common(self):
|
|
"""Diamond (1) to Common (5): -800, min 5."""
|
|
assert calculate_rarity_cost_adjustment(1, 5, 1000) == 200
|
|
assert calculate_rarity_cost_adjustment(1, 5, 500) == 5 # min enforced
|
|
assert calculate_rarity_cost_adjustment(1, 5, 100) == 5 # min enforced
|
|
|
|
def test_diamond_to_special(self):
|
|
"""Diamond (1) to Special (99): +1600, no min."""
|
|
assert calculate_rarity_cost_adjustment(1, 99, 1000) == 2600
|
|
assert calculate_rarity_cost_adjustment(1, 99, 100) == 1700
|
|
|
|
def test_gold_to_diamond(self):
|
|
"""Gold (2) to Diamond (1): +540, no min."""
|
|
assert calculate_rarity_cost_adjustment(2, 1, 200) == 740
|
|
assert calculate_rarity_cost_adjustment(2, 1, 100) == 640
|
|
|
|
def test_gold_to_silver(self):
|
|
"""Gold (2) to Silver (3): -180, min 50."""
|
|
assert calculate_rarity_cost_adjustment(2, 3, 300) == 120
|
|
assert calculate_rarity_cost_adjustment(2, 3, 100) == 50 # min enforced
|
|
|
|
def test_silver_to_gold(self):
|
|
"""Silver (3) to Gold (2): +180, no min."""
|
|
assert calculate_rarity_cost_adjustment(3, 2, 100) == 280
|
|
assert calculate_rarity_cost_adjustment(3, 2, 50) == 230
|
|
|
|
def test_silver_to_bronze(self):
|
|
"""Silver (3) to Bronze (4): -60, min 15."""
|
|
assert calculate_rarity_cost_adjustment(3, 4, 100) == 40
|
|
assert calculate_rarity_cost_adjustment(3, 4, 50) == 15 # min enforced
|
|
|
|
def test_bronze_to_common(self):
|
|
"""Bronze (4) to Common (5): -20, min 5."""
|
|
assert calculate_rarity_cost_adjustment(4, 5, 50) == 30
|
|
assert calculate_rarity_cost_adjustment(4, 5, 20) == 5 # min enforced
|
|
|
|
def test_common_to_bronze(self):
|
|
"""Common (5) to Bronze (4): +20, no min."""
|
|
assert calculate_rarity_cost_adjustment(5, 4, 10) == 30
|
|
assert calculate_rarity_cost_adjustment(5, 4, 50) == 70
|
|
|
|
def test_common_to_diamond(self):
|
|
"""Common (5) to Diamond (1): +800, no min."""
|
|
assert calculate_rarity_cost_adjustment(5, 1, 10) == 810
|
|
assert calculate_rarity_cost_adjustment(5, 1, 50) == 850
|
|
|
|
def test_special_to_diamond(self):
|
|
"""Special (99) to Diamond (1): -1600, min 800."""
|
|
assert calculate_rarity_cost_adjustment(99, 1, 2400) == 800
|
|
assert calculate_rarity_cost_adjustment(99, 1, 2000) == 800 # min enforced
|
|
assert calculate_rarity_cost_adjustment(99, 1, 3000) == 1400
|
|
|
|
def test_special_to_gold(self):
|
|
"""Special (99) to Gold (2): -2140, min 100."""
|
|
assert calculate_rarity_cost_adjustment(99, 2, 2400) == 260
|
|
assert calculate_rarity_cost_adjustment(99, 2, 2000) == 100 # min enforced
|
|
|
|
def test_special_to_common(self):
|
|
"""Special (99) to Common (5): -2400, min 5."""
|
|
assert calculate_rarity_cost_adjustment(99, 5, 2400) == 5 # min enforced
|
|
assert calculate_rarity_cost_adjustment(99, 5, 3000) == 600
|
|
|
|
def test_all_upward_transitions(self):
|
|
"""Test all transitions that increase rarity (decrease number)."""
|
|
# Common (5) moving up
|
|
assert calculate_rarity_cost_adjustment(5, 4, 10) == 30 # +20
|
|
assert calculate_rarity_cost_adjustment(5, 3, 10) == 90 # +80
|
|
assert calculate_rarity_cost_adjustment(5, 2, 10) == 270 # +260
|
|
assert calculate_rarity_cost_adjustment(5, 1, 10) == 810 # +800
|
|
|
|
# Bronze (4) moving up
|
|
assert calculate_rarity_cost_adjustment(4, 3, 30) == 90 # +60
|
|
assert calculate_rarity_cost_adjustment(4, 2, 30) == 270 # +240
|
|
assert calculate_rarity_cost_adjustment(4, 1, 30) == 810 # +780
|
|
|
|
# Silver (3) moving up
|
|
assert calculate_rarity_cost_adjustment(3, 2, 90) == 270 # +180
|
|
assert calculate_rarity_cost_adjustment(3, 1, 90) == 810 # +720
|
|
|
|
# Gold (2) moving up
|
|
assert calculate_rarity_cost_adjustment(2, 1, 270) == 810 # +540
|
|
|
|
def test_all_downward_transitions_with_minimums(self):
|
|
"""Test all transitions that decrease rarity (increase number) with minimum enforcement."""
|
|
# Diamond (1) moving down - all have minimums
|
|
assert (
|
|
calculate_rarity_cost_adjustment(1, 2, 100) == 100
|
|
) # would be -440, min 100
|
|
assert (
|
|
calculate_rarity_cost_adjustment(1, 3, 100) == 50
|
|
) # would be -620, min 50
|
|
assert (
|
|
calculate_rarity_cost_adjustment(1, 4, 100) == 15
|
|
) # would be -680, min 15
|
|
assert calculate_rarity_cost_adjustment(1, 5, 100) == 5 # would be -700, min 5
|
|
|
|
# Gold (2) moving down - all have minimums
|
|
assert calculate_rarity_cost_adjustment(2, 3, 100) == 50 # would be -80, min 50
|
|
assert (
|
|
calculate_rarity_cost_adjustment(2, 4, 100) == 15
|
|
) # would be -140, min 15
|
|
assert calculate_rarity_cost_adjustment(2, 5, 100) == 5 # would be -160, min 5
|
|
|
|
# Silver (3) moving down - all have minimums
|
|
assert calculate_rarity_cost_adjustment(3, 4, 50) == 15 # would be -10, min 15
|
|
assert calculate_rarity_cost_adjustment(3, 5, 50) == 5 # would be -30, min 5
|
|
|
|
def test_edge_cases(self):
|
|
"""Test edge cases: zero cost, very high cost, etc."""
|
|
# Zero cost
|
|
assert calculate_rarity_cost_adjustment(5, 1, 0) == 800
|
|
assert calculate_rarity_cost_adjustment(1, 5, 0) == 5 # min enforced
|
|
|
|
# Very high cost
|
|
assert calculate_rarity_cost_adjustment(5, 1, 10000) == 10800
|
|
assert calculate_rarity_cost_adjustment(99, 1, 10000) == 8400
|
|
|
|
def test_symmetry(self):
|
|
"""Test that adjustments are symmetric (up then down returns close to original)."""
|
|
# Diamond to Common and back (won't be exact due to minimums, but should be logical)
|
|
original = 810
|
|
after_down = calculate_rarity_cost_adjustment(
|
|
1, 5, original
|
|
) # 810 - 800 = 10, min 5 → 5
|
|
after_up = calculate_rarity_cost_adjustment(5, 1, after_down) # 5 + 800 = 805
|
|
assert after_down == 10
|
|
assert after_up == 810
|
|
|
|
# Gold to Bronze and back
|
|
original = 270
|
|
after_down = calculate_rarity_cost_adjustment(2, 4, original) # 270 - 240 = 30
|
|
after_up = calculate_rarity_cost_adjustment(4, 2, after_down) # 30 + 240 = 270
|
|
assert after_down == 30
|
|
assert after_up == 270
|
|
|
|
|
|
class TestRarityCostAdjustmentEdgeCases:
|
|
"""Test edge cases and error handling."""
|
|
|
|
def test_undefined_transition(self):
|
|
"""Test that undefined transitions are handled gracefully."""
|
|
# There's no transition from 1 to 1 (same), but it's handled
|
|
result = calculate_rarity_cost_adjustment(1, 1, 500)
|
|
assert result == 500
|
|
|
|
# There's no transition from rarity 10 (doesn't exist) but should return old cost
|
|
result = calculate_rarity_cost_adjustment(10, 5, 500)
|
|
assert result == 500 # Falls back to old cost
|
|
|
|
def test_negative_costs(self):
|
|
"""Test behavior with negative costs (shouldn't happen, but test it)."""
|
|
# Negative costs should still get adjusted
|
|
result = calculate_rarity_cost_adjustment(5, 1, -100)
|
|
assert result == 700 # -100 + 800 = 700
|