"""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