simulator / tests /test_calculations.py
mathiassandnes's picture
Claude Opus 4.5
Add test suite, CI/CD, and development workflow
85fcbc2
Raw History Blame Contribute Delete
6.52 kB
"""Tests for core business calculations."""
import pytest
def calculate_eolrr(return_rate: float, grade_a: float, grade_b: float) -> float:
"""Calculate End-of-Life Recovery Rate."""
return return_rate * (grade_a + grade_b)
def calculate_circular_profit(
new_unit_cost: float,
refurb_unit_cost: float,
revenue_per_cycle: float,
num_cycles: int
) -> float:
"""Calculate profit for circular model (1 product, N cycles)."""
total_cost = new_unit_cost + (num_cycles - 1) * refurb_unit_cost
total_revenue = num_cycles * revenue_per_cycle
return total_revenue - total_cost
def calculate_linear_profit(
new_unit_cost: float,
revenue_per_cycle: float,
num_cycles: int
) -> float:
"""Calculate profit for linear model (N products, 1 cycle each)."""
total_cost = num_cycles * new_unit_cost
total_revenue = num_cycles * revenue_per_cycle
return total_revenue - total_cost
class TestEoLRRCalculation:
"""Test EoLRR calculation."""
def test_eolrr_with_perfect_returns(self):
"""100% return rate, 100% grade A+B = 100% EoLRR."""
result = calculate_eolrr(1.0, 0.95, 0.05)
assert result == 1.0
def test_eolrr_with_partial_returns(self):
"""90% return rate, 95% reusable = 85.5% EoLRR."""
result = calculate_eolrr(0.90, 0.80, 0.15)
assert abs(result - 0.855) < 0.001
def test_eolrr_zero_returns(self):
"""0% return rate = 0% EoLRR."""
result = calculate_eolrr(0.0, 0.80, 0.15)
assert result == 0.0
def test_eolrr_from_config(self, besafe_config):
"""Calculate EoLRR from actual config."""
assumptions = besafe_config["return_assumptions"]
dist = assumptions["grade_distribution"]
result = calculate_eolrr(
assumptions["return_rate"],
dist["a"],
dist["b"]
)
# BeSafe: 0.90 × (0.80 + 0.15) = 0.855
assert 0 < result < 1
class TestCircularVsLinearProfit:
"""Test circular model beats linear model."""
def test_circular_beats_linear_after_one_cycle(self):
"""Circular profit > linear profit for cycles > 1."""
new_cost = 100
refurb_cost = 30
revenue = 80
# At 2 cycles
circular = calculate_circular_profit(new_cost, refurb_cost, revenue, 2)
linear = calculate_linear_profit(new_cost, revenue, 2)
assert circular > linear, f"Circular ({circular}) should beat linear ({linear}) at 2 cycles"
# At 3 cycles
circular = calculate_circular_profit(new_cost, refurb_cost, revenue, 3)
linear = calculate_linear_profit(new_cost, revenue, 3)
assert circular > linear, f"Circular ({circular}) should beat linear ({linear}) at 3 cycles"
def test_advantage_increases_with_cycles(self):
"""Circular advantage grows with more cycles."""
new_cost = 100
refurb_cost = 30
revenue = 80
advantages = []
for cycles in [2, 3, 4, 5]:
circular = calculate_circular_profit(new_cost, refurb_cost, revenue, cycles)
linear = calculate_linear_profit(new_cost, revenue, cycles)
advantages.append(circular - linear)
# Each advantage should be greater than the previous
for i in range(1, len(advantages)):
assert advantages[i] > advantages[i-1], \
f"Advantage should increase: {advantages[i-1]} -> {advantages[i]}"
def test_with_config_values(self, besafe_config):
"""Test with actual config values."""
costs = besafe_config["costs"]
pricing = besafe_config["pricing"]
design = besafe_config["design"]
new_cost = costs["manufacturing_unit_cost"] + costs["logistics"]["delivery"] + costs["logistics"]["return"]
refurb_cost = costs["refurbishment"]["grade_a"] + costs["logistics"]["delivery"] + costs["logistics"]["return"]
revenue = pricing["lease_monthly"] * pricing["lease_term_months"]
cycles = design["max_cycles"]
circular = calculate_circular_profit(new_cost, refurb_cost, revenue, cycles)
linear = calculate_linear_profit(new_cost, revenue, cycles)
assert circular > linear, f"Circular ({circular}) should beat linear ({linear})"
class TestCostPerUse:
"""Test cost per use calculations."""
def test_cost_per_use_decreases_with_cycles(self):
"""Amortized cost per use decreases as cycles increase."""
new_cost = 100
refurb_cost = 30
costs_per_use = []
for cycles in range(1, 6):
total_cost = new_cost + (cycles - 1) * refurb_cost
cost_per_use = total_cost / cycles
costs_per_use.append(cost_per_use)
# Each cost per use should be less than or equal to previous
for i in range(1, len(costs_per_use)):
assert costs_per_use[i] <= costs_per_use[i-1], \
f"Cost per use should decrease: {costs_per_use[i-1]} -> {costs_per_use[i]}"
class TestFleetScaleEconomics:
"""Test fleet scale calculations."""
def test_customers_served_equals_fleet_times_cycles(self):
"""Total customers = fleet size × cycles."""
fleet = 1000
cycles = 3
customers = fleet * cycles
assert customers == 3000
def test_products_saved_calculation(self):
"""Products saved = linear products - circular products."""
fleet = 5000
cycles = 3
customers = fleet * cycles # 15000
linear_products = customers # Need 15000 products
circular_products = fleet # Need only 5000 products
saved = linear_products - circular_products
assert saved == 10000
def test_circular_fleet_profit_beats_linear(self):
"""Fleet-level circular profit beats linear for same customer count."""
fleet = 1000
cycles = 3
new_cost = 100
refurb_cost = 30
revenue = 80
customers = fleet * cycles # 3000
# Circular: manufacture fleet once, refurb for subsequent cycles
circular_cost = fleet * new_cost + fleet * (cycles - 1) * refurb_cost
circular_revenue = customers * revenue
circular_profit = circular_revenue - circular_cost
# Linear: manufacture new product for each customer
linear_cost = customers * new_cost
linear_revenue = customers * revenue
linear_profit = linear_revenue - linear_cost
assert circular_profit > linear_profit