Spaces:
Running
Running
Download tests/test_calculations.py from Liisdotcom/simulator: direct link, hf CLI and curl.
- Browser
- Download file 6.52 kB
-
https://huggingface.co/spaces/Liisdotcom/simulator/resolve/main/tests/test_calculations.py
- Command line
-
hf download hf://spaces/Liisdotcom/simulator/tests/test_calculations.py
-
curl -L -o test_calculations.py https://huggingface.co/spaces/Liisdotcom/simulator/resolve/main/tests/test_calculations.py
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 | |