# retoor <retoor@molodetz.nl>
from devplacepy.services.game import economy
def test_level_thresholds():
assert economy.level_for_xp(0) == 1
assert economy.level_for_xp(economy.xp_threshold(2)) == 2
assert economy.level_for_xp(economy.xp_threshold(5)) == 5
assert economy.level_for_xp(economy.xp_threshold(economy.MAX_LEVEL) + 9999) == economy.MAX_LEVEL
def test_level_progress_span():
progress = economy.level_progress(economy.xp_threshold(3))
assert progress["level"] == 3
assert progress["into_level"] == 0
assert progress["is_max"] is False
def test_plot_cost_doubles():
assert economy.plot_cost(economy.STARTING_PLOTS) == economy.PLOT_BASE_COST
assert economy.plot_cost(economy.STARTING_PLOTS + 1) == economy.PLOT_BASE_COST * 2
assert economy.plot_cost(economy.STARTING_PLOTS + 2) == economy.PLOT_BASE_COST * 4
def test_perk_cost_grows():
perk = economy.perk_for("yield")
assert economy.perk_cost(perk, 0) == perk.base_cost
assert economy.perk_cost(perk, 1) == round(perk.base_cost * perk.cost_growth)
assert economy.perk_cost(perk, 2) > economy.perk_cost(perk, 1)
def test_daily_reward_streak_and_cap():
assert economy.daily_reward(1) == economy.DAILY_BASE
assert economy.daily_reward(2) == economy.DAILY_BASE + economy.DAILY_STREAK_STEP
assert economy.daily_reward(99) == economy.daily_reward(economy.DAILY_STREAK_CAP)
def test_effective_plant_cost_discount():
crop = economy.crop_for("python")
assert economy.effective_plant_cost(crop, 0) == crop.cost
assert economy.effective_plant_cost(crop, 3) < crop.cost
assert economy.effective_plant_cost(crop, 3) >= 1
def test_effective_reward_coins_yield_and_prestige():
crop = economy.crop_for("shell")
assert economy.effective_reward_coins(crop, 0, 0) == crop.reward_coins
assert economy.effective_reward_coins(crop, 4, 0) > crop.reward_coins
assert economy.effective_reward_coins(crop, 0, 2) > crop.reward_coins
def test_effective_reward_xp():
crop = economy.crop_for("shell")
assert economy.effective_reward_xp(crop, 0) == crop.reward_xp
assert economy.effective_reward_xp(crop, 10) > crop.reward_xp
def test_growth_perk_speeds_build():
crop = economy.crop_for("python")
assert economy.grow_seconds_for(crop, 1, 5) < economy.grow_seconds_for(crop, 1, 0)
def test_ci_tier_speeds_build():
crop = economy.crop_for("python")
assert economy.grow_seconds_for(crop, 2, 0) < economy.grow_seconds_for(crop, 1, 0)
def test_prestige_multiplier():
assert economy.prestige_multiplier(0) == 1.0
assert economy.prestige_multiplier(2) == 1 + 2 * economy.PRESTIGE_BONUS
def test_fertilize_cost_has_floor():
assert economy.fertilize_click_cost(1, 1, 1_000_000) == 1
assert economy.fertilize_click_cost(10_000, 50, 100) > 1
def test_crop_payload_locked_flag():
rust = economy.crop_for("rust")
assert economy.crop_payload(rust, 1, 1)["locked"] is True
assert economy.crop_payload(rust, 1, rust.min_level)["locked"] is False
def test_crop_payload_reflects_perks():
crop = economy.crop_for("python")
base = economy.crop_payload(crop, 1, 5)
boosted = economy.crop_payload(crop, 1, 5, growth_level=5, discount_level=3, yield_level=4, prestige=1)
assert boosted["cost"] < base["cost"]
assert boosted["grow_seconds"] < base["grow_seconds"]
assert boosted["reward_coins"] > base["reward_coins"]
def test_daily_quests_deterministic_count_and_kinds():
first = economy.daily_quests("user-xyz", "2026-06-22")
second = economy.daily_quests("user-xyz", "2026-06-22")
assert first == second
assert len(first) == economy.DAILY_QUEST_COUNT
assert all(quest["kind"] in economy.QUEST_DEFS for quest in first)
assert all(quest["goal"] > 0 for quest in first)
def test_farm_score_empty_is_zero():
assert economy.farm_score({}) == 0
def test_farm_score_counts_every_factor():
score = economy.farm_score(
{
"xp": 100,
"prestige": 2,
"total_harvests": 3,
"coins": 200,
"ci_tier": 3,
"plot_count": economy.STARTING_PLOTS + 2,
"perk_yield": 1,
"perk_growth": 1,
"perk_discount": 1,
"perk_xp": 1,
"streak": 4,
}
)
expected = (
100
+ 2 * economy.SCORE_PRESTIGE
+ 3 * economy.SCORE_HARVEST
+ 200 // economy.SCORE_COIN_DIVISOR
+ (3 - 1) * economy.SCORE_CI
+ 2 * economy.SCORE_PLOT
+ 4 * economy.SCORE_PERK
+ 4 * economy.SCORE_STREAK
)
assert score == expected
def test_farm_score_prestige_is_additive_and_substantial():
base = {"xp": 800, "total_harvests": 5}
with_prestige = {**base, "prestige": 1}
gain = economy.farm_score(with_prestige) - economy.farm_score(base)
assert gain == economy.SCORE_PRESTIGE
assert gain >= economy.xp_threshold(economy.PRESTIGE_MIN_LEVEL)
def test_farm_score_prestige_lifts_above_lower_level_player():
refactorer = {"xp": 200, "prestige": 1}
higher_level_no_prestige = {"xp": economy.xp_threshold(5)}
assert economy.farm_score(refactorer) > economy.farm_score(higher_level_no_prestige)
def test_farm_score_streak_is_capped():
capped = economy.farm_score({"streak": economy.SCORE_STREAK_CAP})
over = economy.farm_score({"streak": economy.SCORE_STREAK_CAP + 50})
assert capped == over
def test_farm_score_handles_legacy_null_columns():
assert economy.farm_score(
{"xp": 50, "prestige": None, "perk_yield": None, "streak": None}
) == 50
# --- legacy upgrades ---------------------------------------------------------
def test_legacy_for_known_and_unknown():
assert economy.legacy_for("multiplier") is not None
assert economy.legacy_for("does_not_exist") is None
def test_legacy_cost_grows_with_level():
up = economy.legacy_for("multiplier")
assert economy.legacy_cost(up, 0) == up.base_cost
assert economy.legacy_cost(up, 2) > economy.legacy_cost(up, 1)
def test_legacy_multiplier_steps():
assert economy.legacy_multiplier(0) == 1.0
assert economy.legacy_multiplier(3) == 1 + economy.LEGACY_MULT_STEP * 3
def test_stars_for_refactor_scales_with_level_and_prestige():
assert economy.stars_for_refactor(0, 0) == economy.STAR_BASE
assert economy.stars_for_refactor(10, 0) == economy.STAR_BASE + 2
assert economy.stars_for_refactor(0, 2) == economy.STAR_BASE + 2
def test_prestige_base_plots_adds_legacy_plots():
assert economy.prestige_base_plots(0) == economy.STARTING_PLOTS
assert economy.prestige_base_plots(3) == economy.STARTING_PLOTS + 3
# --- steal economy -----------------------------------------------------------
def test_effective_steal_grace_extends_with_defense():
assert economy.effective_steal_grace(0) == economy.STEAL_GRACE_SECONDS
assert economy.effective_steal_grace(2) == (
economy.STEAL_GRACE_SECONDS + economy.LEGACY_DEFENSE_GRACE * 2
)
def test_effective_steal_fraction_drops_with_defense_and_has_floor():
assert economy.effective_steal_fraction(0) == economy.STEAL_FRACTION
assert economy.effective_steal_fraction(2) < economy.STEAL_FRACTION
assert economy.effective_steal_fraction(99) >= 0.1
def test_steal_reward_coins_is_a_fraction_of_harvest():
crop = economy.crop_for("shell")
full = economy.effective_reward_coins(crop)
stolen = economy.steal_reward_coins(crop)
assert 0 < stolen <= full
# --- golden crops ------------------------------------------------------------
def test_is_golden_deterministic_and_bounded():
first = economy.is_golden("plot-7", "2026-06-20T00:00:00+00:00")
second = economy.is_golden("plot-7", "2026-06-20T00:00:00+00:00")
assert first == second
assert isinstance(first, bool)
def test_is_golden_requires_both_args():
assert economy.is_golden("", "2026-06-20T00:00:00+00:00") is False
assert economy.is_golden("plot-7", "") is False
# --- market saturation --------------------------------------------------------
def test_market_saturation_factor_is_full_when_fresh():
assert economy.market_saturation_factor(0.0) == 1.0
def test_market_saturation_factor_steps_down():
assert economy.market_saturation_factor(8.0) < 1.0
assert economy.market_saturation_factor(96.0) == 0.40
assert economy.market_saturation_factor(8.0) > economy.market_saturation_factor(96.0)
def test_market_saturation_factor_is_monotone_non_increasing():
previous = 1.0
step = 0
while step <= 400:
supply = step * 0.5
factor = economy.market_saturation_factor(supply)
assert factor <= previous
previous = factor
step += 1
def test_supply_days_normalizes_by_grow_time():
shell = economy.crop_for("shell")
kernel = economy.crop_for("kernel")
assert economy.supply_days(shell, 0) == 0.0
assert economy.supply_days(shell, 5760) == economy.supply_days(kernel, 24)
assert economy.supply_days(shell, 2880) == 1.0
assert economy.supply_days(kernel, 12) == 1.0
def test_market_buff_factor_only_applies_to_starter_crops():
assert economy.market_buff_factor("kernel", 0.60) == 1.0
assert economy.market_buff_factor("shell", 0.0) == 1.0
assert economy.market_buff_factor("shell", 0.15) == 1.0375
assert economy.market_buff_factor("shell", 0.60) == economy.MARKET_BUFF_CAP
assert economy.market_buff_factor("shell", 0.90) == economy.MARKET_BUFF_CAP
def test_market_factor_bounds_across_domain():
floor = economy.MARKET_SATURATION_TIERS[-1][1]
for key in economy.MARKET_BUFFED_CROPS + economy.MARKET_PRESSURE_CROPS:
crop = economy.crop_for(key)
for harvests in range(0, 300000, 977):
saturation = economy.market_saturation_factor(economy.supply_days(crop, harvests))
for pressure in (0.0, 0.15, 0.30, 0.45, 0.60):
factor = saturation if saturation < 1.0 else economy.market_buff_factor(key, pressure)
assert floor <= factor <= economy.MARKET_BUFF_CAP
if saturation < 1.0:
assert factor == saturation
else:
assert factor >= 1.0
def test_effective_reward_coins_applies_market_factor():
crop = economy.crop_for("shell")
full = economy.effective_reward_coins(crop, 0, 0, 0, 1.0)
saturated = economy.effective_reward_coins(crop, 0, 0, 0, 0.5)
assert saturated < full
assert saturated == round(crop.reward_coins * 0.5)
def test_effective_reward_coins_underdog_multiplier():
crop = economy.crop_for("shell")
plain = economy.effective_reward_coins(crop, 0, 0, 0, 1.0, False)
boosted = economy.effective_reward_coins(crop, 0, 0, 0, 1.0, True)
assert boosted == round(crop.reward_coins * economy.UNDERDOG_MULTIPLIER)
assert boosted > plain
# --- infrastructure and defense ------------------------------------------------
def test_infra_for_known_and_unknown():
assert economy.infra_for("registry") is not None
assert economy.infra_for("does_not_exist") is None
def test_registry_boost_speeds_only_named_crops():
kernel = economy.crop_for("kernel")
shell = economy.crop_for("shell")
assert economy.grow_seconds_for(kernel, 1, 0, 0, True) < economy.grow_seconds_for(
kernel, 1, 0, 0, False
)
assert economy.grow_seconds_for(shell, 1, 0, 0, True) == economy.grow_seconds_for(
shell, 1, 0, 0, False
)
def test_defense_tier_lookup_and_progression():
assert economy.defense_tier(0).name == "Undefended"
assert economy.defense_tier(0).upkeep_daily == 0
top = economy.defense_tier(economy.MAX_DEFENSE_LEVEL)
assert economy.next_defense_tier(economy.MAX_DEFENSE_LEVEL) is None
assert economy.next_defense_tier(0) is not None
assert top.steal_fraction_floor < economy.defense_tier(0).steal_fraction_floor
def test_daily_upkeep_scales_with_wealth():
tier = economy.defense_tier(1)
assert economy.daily_upkeep(tier, 0) == tier.upkeep_daily
rich = economy.daily_upkeep(tier, 10_000_000)
assert rich > tier.upkeep_daily
assert rich == round(10_000_000 * economy.UPKEEP_WEALTH_PCT)
def test_effective_steal_fraction_floor_overridden_by_building():
assert economy.effective_steal_fraction(99, floor=0.30) == 0.30
assert economy.effective_steal_fraction(0, floor=0.30) == economy.STEAL_FRACTION
def test_effective_steal_grace_extra_seconds_from_building():
base = economy.effective_steal_grace(0, 0)
with_building = economy.effective_steal_grace(0, 30)
assert with_building == base + 30
# --- cosmetics ------------------------------------------------------------------
def test_cosmetic_for_known_and_unknown():
assert economy.cosmetic_for("title_architect") is not None
assert economy.cosmetic_for("does_not_exist") is None
def test_cosmetic_title_name_only_resolves_titles():
assert economy.cosmetic_title_name("title_architect") == "The Architect"
assert economy.cosmetic_title_name("skin_neon") == ""
assert economy.cosmetic_title_name("") == ""
assert economy.cosmetic_title_name("does_not_exist") == ""
# --- mastery --------------------------------------------------------------------
def test_mastery_points_awarded_first_point_at_unlock():
step = economy.MASTERY_PRESTIGE_STEP
unlock = economy.MASTERY_UNLOCK_PRESTIGE
assert economy.mastery_points_awarded(unlock - 1, unlock) == 1
assert economy.mastery_points_awarded(0, unlock - 1) == 0
assert economy.mastery_points_awarded(unlock, unlock + step - 1) == 0
assert economy.mastery_points_awarded(unlock + step - 1, unlock + step) == 1
assert economy.mastery_points_awarded(unlock, unlock + step * 2) == 2
def test_mastery_for_known_and_unknown():
assert economy.mastery_for("autoreplant") is not None
assert economy.mastery_for("does_not_exist") is None
def test_mastery_cost_grows_with_level():
m = economy.mastery_for("contracts")
assert economy.mastery_cost(m, 0) == m.base_cost
def test_unlocked_crops_gates_on_mastery_and_level():
base = economy.unlocked_crops(economy.MAX_LEVEL, mastery_earned=0)
with_mastery = economy.unlocked_crops(economy.MAX_LEVEL, mastery_earned=1)
assert "distsys" not in {c.key for c in base}
assert "distsys" in {c.key for c in with_mastery}
def test_crop_payload_locked_by_mastery():
distsys = economy.crop_for("distsys")
assert economy.crop_payload(distsys, 1, economy.MAX_LEVEL, mastery_earned=0)["locked"] is True
assert economy.crop_payload(distsys, 1, economy.MAX_LEVEL, mastery_earned=1)["locked"] is False
def test_secfort_crop_is_steal_immune():
secfort = economy.crop_for("secfort")
assert secfort.steal_immune is True
assert economy.crop_for("shell").steal_immune is False
# --- secondary leaderboard scoring -----------------------------------------------
def test_fair_play_score_rewards_activity_and_penalizes_hoarding():
active = economy.fair_play_score(harvests_week=20, coins=0)
hoarder = economy.fair_play_score(harvests_week=0, coins=10_000_000)
assert active > hoarder
# --- era --------------------------------------------------------------------------
def test_era_score_gives_prestige_partial_weight():
veteran = economy.era_score(era_coins=0, era_harvests=0, prestige=10)
rookie = economy.era_score(era_coins=0, era_harvests=0, prestige=0)
assert veteran > rookie
assert veteran == round(10 * economy.SCORE_PRESTIGE * economy.ERA_PRESTIGE_CARRYOVER_PCT)
def test_era_reward_stars_by_rank():
assert economy.era_reward_stars(1) == economy.ERA_REWARD_STARS_BY_RANK[0]
assert economy.era_reward_stars(len(economy.ERA_REWARD_STARS_BY_RANK) + 1) == 0
assert economy.era_reward_stars(0) == 0
# --- weekly contracts ---------------------------------------------------------------
def test_weekly_contract_deterministic():
first = economy.weekly_contract("user-xyz", "2026-W10")
second = economy.weekly_contract("user-xyz", "2026-W10")
assert first == second
assert first["kind"] in economy.QUEST_DEFS
assert first["reward_stars"] > 0
# --- refactor fee, carry-over, and grants -------------------------------------------
def test_refactor_cost_monotonic_in_prestige():
previous = 0
for prestige in range(0, 200):
cost = economy.refactor_cost(prestige, 0)
assert cost > previous
previous = cost
def test_refactor_cost_monotonic_in_wealth():
previous = -1
for coins in range(0, 2_000_000, 10_000):
cost = economy.refactor_cost(0, coins)
assert cost >= previous
previous = cost
def test_refactor_cost_floor_is_base():
assert economy.refactor_cost(0, 0) == economy.REFACTOR_BASE_COST
assert economy.refactor_cost(-5, -100) == economy.REFACTOR_BASE_COST
def test_refactor_cost_includes_wealth_tax():
coins = 100_000
expected = round(
economy.REFACTOR_BASE_COST + economy.REFACTOR_WEALTH_PCT * coins
)
assert economy.refactor_cost(0, coins) == expected
def test_refactor_carryover_fraction_bounds():
for level in range(0, 50):
fraction = economy.refactor_carryover_fraction(level)
assert economy.REFACTOR_CARRYOVER_BASE <= fraction <= economy.REFACTOR_CARRYOVER_MAX
def test_refactor_carryover_never_exceeds_remainder():
for coins in range(0, 500_000, 7_777):
for level in (0, 3, 5):
fee = economy.refactor_cost(0, coins)
carried = economy.refactor_carryover(coins, fee, level)
assert 0 <= carried <= max(0, coins - fee)
def test_refactor_carryover_zero_when_unaffordable():
assert economy.refactor_carryover(100, 20_000, 5) == 0
def test_grant_amount_capped_and_bounded():
assert economy.grant_amount(0) == 0
assert economy.grant_amount(-10) == 0
assert economy.grant_amount(100) == 0
assert economy.grant_amount(economy.GRANT_MIN_AMOUNT) == economy.GRANT_MIN_AMOUNT
assert economy.grant_amount(10**9) == economy.GRANT_CAP
def test_grant_amount_shares_between_eligible_farms():
assert economy.grant_amount(10_000, 5) == 2_000
assert economy.grant_amount(10**9, 4) == economy.GRANT_CAP
assert economy.grant_amount(1_000, 10) == 0
for eligible in range(1, 50):
share = economy.grant_amount(10**6, eligible)
assert 0 <= share <= economy.GRANT_CAP
assert share * eligible <= 10**6 or share == economy.GRANT_CAP
def test_legacy_carryover_upgrade_registered():
upgrade = economy.legacy_for("carryover")
assert upgrade is not None
assert upgrade.max_level == 10
assert "carry-over" in economy.legacy_value_text(upgrade, 2)
assert economy.refactor_carryover_fraction(upgrade.max_level) < 1.0
def test_fertilize_is_never_profitable_across_the_input_domain():
import itertools
for crop in economy.CROPS:
for prestige in range(0, 201, 23):
for yield_level in (0, 5, 10):
for legacy in (0, 5, 10):
for market in (0.40, 0.70, 1.0, 1.15):
for golden, contract, underdog in itertools.product(
(False, True), repeat=3
):
value = economy.realizable_harvest_coins(
crop,
yield_level,
prestige,
legacy,
market,
golden,
contract,
underdog,
)
cost = economy.fertilize_click_cost(
value, crop.grow_seconds, crop.grow_seconds
)
assert cost >= value, (
crop.key,
prestige,
golden,
contract,
underdog,
cost,
value,
)
def test_fertilize_priced_above_the_expected_canary_payout():
for crop in economy.CROPS:
for prestige in (0, 25, 100):
plain = economy.realizable_harvest_coins(crop, 10, prestige, 10, 1.0)
priced = economy.realizable_harvest_coins(
crop, 10, prestige, 10, 1.0, canary=True
)
cost = economy.fertilize_click_cost(
priced, crop.grow_seconds, crop.grow_seconds
)
expected = plain * (
economy.CANARY_DOUBLE_CHANCE * 2
+ (1 - economy.CANARY_DOUBLE_CHANCE - economy.CANARY_FAIL_CHANCE)
) + economy.CANARY_FAIL_CHANCE * min(plain, crop.cost)
assert cost >= expected
def test_staged_fertilize_never_undercuts_the_payout():
for key in ("shell", "api", "kernel", "secfort"):
crop = economy.crop_for(key)
value = economy.realizable_harvest_coins(crop, 10, 50, 10, 1.0, True, True, True)
remaining, total = crop.grow_seconds, 0
while True:
reduce_by = int(remaining * economy.FERTILIZE_FRACTION)
if reduce_by < 1:
break
total += economy.fertilize_click_cost(value, reduce_by, crop.grow_seconds)
remaining -= reduce_by
assert total >= value
def test_every_defense_tier_reduces_the_raider_share():
shares = []
for tier in economy.DEFENSE_TIERS:
share = economy.effective_steal_fraction(
0, tier.steal_fraction_floor, tier.steal_reduction
)
shares.append(round(share, 4))
assert len(set(shares)) == len(economy.DEFENSE_TIERS)
assert shares == sorted(shares, reverse=True)
def test_more_defense_never_increases_the_raider_share():
previous = 1.0
for tier in economy.DEFENSE_TIERS:
for legacy in range(0, 6):
share = economy.effective_steal_fraction(
legacy, tier.steal_fraction_floor, tier.steal_reduction
)
assert 0.0 <= share <= 1.0
top = economy.effective_steal_fraction(
0, tier.steal_fraction_floor, tier.steal_reduction
)
assert top <= previous + 1e-9
previous = top
def test_observability_only_ever_lowers_the_raider_share():
for tier in economy.DEFENSE_TIERS:
for legacy in range(0, 6):
without = economy.effective_steal_fraction(
legacy, tier.steal_fraction_floor, tier.steal_reduction
)
with_suite = economy.effective_steal_fraction(
legacy,
tier.steal_fraction_floor,
tier.steal_reduction,
economy.OBSERVABILITY_STEAL_CAP,
)
assert with_suite <= without + 1e-9
assert with_suite <= economy.OBSERVABILITY_STEAL_CAP + 1e-9
def test_raid_share_plus_owner_remainder_never_exceeds_the_build():
for crop in economy.CROPS:
for prestige in range(0, 101, 17):
for golden in (False, True):
value = economy.realizable_harvest_coins(
crop, 10, prestige, 10, 1.0, golden
)
for tier in economy.DEFENSE_TIERS:
for legacy in range(0, 6):
share = economy.effective_steal_fraction(
legacy, tier.steal_fraction_floor, tier.steal_reduction
)
thief = min(max(1, round(value * share)), int(value * (1.0 - 0.0)))
owner = int(value * (1.0 - share))
assert thief + owner <= value
def test_weekly_contract_stars_are_per_kind_not_per_goal():
for kind in economy.QUEST_KINDS:
for scale in (1.0, 13.5, 40.0):
contract = economy.weekly_contract("user-a", "2026-W30", scale)
if contract["kind"] != kind:
continue
assert contract["reward_stars"] == economy.QUEST_DEFS[kind].contract_stars
assert contract["reward_stars"] <= 5
def test_social_rewards_scale_with_the_earner_and_never_regress():
assert economy.water_reward_coins(0, 0) == economy.WATER_REWARD_COINS
assert economy.daily_reward(1) == economy.DAILY_BASE
previous = 0
for prestige in range(0, 101):
reward = economy.water_reward_coins(prestige, 0)
assert reward >= previous
previous = reward
def test_leaderboard_coin_contribution_is_capped():
base = {"xp": 18050, "prestige": 50, "total_harvests": 5000, "ci_tier": 5}
poor = economy.farm_score({**base, "coins": 0})
rich = economy.farm_score({**base, "coins": 10**9})
assert rich - poor <= economy.SCORE_COIN_CAP
def test_market_saturation_is_per_capita():
crop = economy.crop_for("kernel")
assert economy.supply_days(crop, 288, 1) == economy.supply_days(crop, 2880, 10)
assert economy.supply_days(crop, 288, 4) < economy.supply_days(crop, 288, 1)
Reference in New Issue View Git Blame Copy Permalink