186 lines
7.3 KiB
Python
186 lines
7.3 KiB
Python
"""Tests for the constraint resolver engine."""
|
|
|
|
from physcom.engine.constraint_resolver import ConstraintResolver
|
|
from physcom.models.combination import Combination
|
|
from physcom.models.entity import Entity, Dependency
|
|
|
|
|
|
def test_compatible_ground_combo(bicycle, human_pedalling, food_calories):
|
|
"""Bicycle + Human Pedalling + Food/Calories should be valid."""
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[bicycle, human_pedalling, food_calories])
|
|
result = resolver.resolve(combo)
|
|
assert result.status != "p1_fail", f"Unexpected block: {result.violations}"
|
|
|
|
|
|
def test_solar_sail_blocks_with_walking(walking, solar_sail, solar_radiation):
|
|
"""Walking (ground) + Solar Sail (space) should be blocked by medium mutex."""
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[walking, solar_sail, solar_radiation])
|
|
result = resolver.resolve(combo)
|
|
assert result.status == "p1_fail"
|
|
assert any("mutually exclusive" in v for v in result.violations)
|
|
|
|
|
|
def test_spaceship_compatible_with_solar_sail(spaceship, solar_sail, solar_radiation):
|
|
"""Spaceship + Solar Sail both need space/vacuum — should not conflict."""
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[spaceship, solar_sail, solar_radiation])
|
|
result = resolver.resolve(combo)
|
|
# Should not be blocked by atmosphere or medium
|
|
medium_blocks = [v for v in result.violations if "mutually exclusive" in v]
|
|
assert len(medium_blocks) == 0
|
|
|
|
|
|
def test_nuclear_drive_blocks_with_bicycle(bicycle, nuclear_thermal_drive, nuclear_fuel):
|
|
"""Nuclear drive min_mass=1500kg + fuel min_mass=500kg vs bicycle max_mass=30kg → range incompatibility."""
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[bicycle, nuclear_thermal_drive, nuclear_fuel])
|
|
result = resolver.resolve(combo)
|
|
assert result.status == "p1_fail"
|
|
assert any("mass" in v.lower() for v in result.violations)
|
|
|
|
|
|
def test_power_density_mismatch_blocks():
|
|
"""A platform needing 500 W/kg and a source providing 0.01 W/kg → block."""
|
|
platform = Entity(
|
|
name="HeavyPlatform", dimension="platform",
|
|
dependencies=[
|
|
Dependency("force", "power_density_required_w_kg", "500", "W/kg", "range_min"),
|
|
],
|
|
)
|
|
power = Entity(
|
|
name="TinyPower", dimension="actuator",
|
|
dependencies=[
|
|
Dependency("force", "power_density_w_kg", "0.01", "W/kg", "provides"),
|
|
],
|
|
)
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[platform, power])
|
|
result = resolver.resolve(combo)
|
|
assert result.status == "p1_fail"
|
|
assert any("power density deficit" in v for v in result.violations)
|
|
|
|
|
|
def test_power_density_under_powered_warning():
|
|
"""Power source slightly below requirement → warning, not block."""
|
|
platform = Entity(
|
|
name="MedPlatform", dimension="platform",
|
|
dependencies=[
|
|
Dependency("force", "power_density_required_w_kg", "100", "W/kg", "range_min"),
|
|
],
|
|
)
|
|
power = Entity(
|
|
name="WeakPower", dimension="actuator",
|
|
dependencies=[
|
|
Dependency("force", "power_density_w_kg", "50", "W/kg", "provides"),
|
|
],
|
|
)
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[platform, power])
|
|
result = resolver.resolve(combo)
|
|
# Under-powered but within 100x → warning, not block
|
|
assert result.status != "p1_fail"
|
|
assert any("under-powered" in w for w in result.warnings)
|
|
|
|
|
|
def test_requires_vs_excludes():
|
|
"""Direct requires/excludes contradiction."""
|
|
a = Entity(
|
|
name="A", dimension="platform",
|
|
dependencies=[Dependency("environment", "oxygen", "true", None, "requires")],
|
|
)
|
|
b = Entity(
|
|
name="B", dimension="actuator",
|
|
dependencies=[Dependency("environment", "oxygen", "true", None, "excludes")],
|
|
)
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[a, b])
|
|
result = resolver.resolve(combo)
|
|
assert result.status == "p1_fail"
|
|
assert any("excludes" in v for v in result.violations)
|
|
|
|
|
|
def test_ice_engine_blocks_with_spaceship(spaceship, ice_engine, gasoline):
|
|
"""ICE requires standard atmosphere, spaceship requires vacuum_or_thin → mutex."""
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[spaceship, ice_engine, gasoline])
|
|
result = resolver.resolve(combo)
|
|
assert result.status == "p1_fail"
|
|
assert any("atmosphere" in v for v in result.violations)
|
|
|
|
|
|
def test_hydrogen_bicycle_valid(bicycle, hydrogen_engine, hydrogen):
|
|
"""Hydrogen bike — the README's example of a plausible novel concept."""
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[bicycle, hydrogen_engine, hydrogen])
|
|
result = resolver.resolve(combo)
|
|
# Should pass constraints (mass range is compatible: h2 engine min 25kg, bike max 30kg)
|
|
# This is actually a borderline case — let's just verify no hard physics blocks
|
|
range_blocks = [v for v in result.violations if "mutually exclusive" in v or "atmosphere" in v]
|
|
assert len(range_blocks) == 0
|
|
|
|
|
|
def test_energy_density_deficit_blocks():
|
|
"""A platform needing 2000 Wh/kg paired with a 200 Wh/kg battery → blocked."""
|
|
platform = Entity(
|
|
name="Spaceship", dimension="platform",
|
|
dependencies=[
|
|
Dependency("physical", "energy_density_wh_kg", "2000", "Wh/kg", "range_min"),
|
|
],
|
|
)
|
|
storage = Entity(
|
|
name="Battery", dimension="energy_storage",
|
|
dependencies=[
|
|
Dependency("physical", "energy_density_wh_kg", "200", "Wh/kg", "provides"),
|
|
],
|
|
)
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[platform, storage])
|
|
result = resolver.resolve(combo)
|
|
assert result.status == "p1_fail"
|
|
assert any("energy density deficit" in v for v in result.violations)
|
|
|
|
|
|
def test_energy_density_under_density_warning():
|
|
"""A platform needing 400 Wh/kg paired with a 200 Wh/kg battery → conditional."""
|
|
platform = Entity(
|
|
name="Airplane", dimension="platform",
|
|
dependencies=[
|
|
Dependency("physical", "energy_density_wh_kg", "400", "Wh/kg", "range_min"),
|
|
],
|
|
)
|
|
storage = Entity(
|
|
name="Battery", dimension="energy_storage",
|
|
dependencies=[
|
|
Dependency("physical", "energy_density_wh_kg", "200", "Wh/kg", "provides"),
|
|
],
|
|
)
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[platform, storage])
|
|
result = resolver.resolve(combo)
|
|
assert result.status != "p1_fail"
|
|
assert any("under-density" in w for w in result.warnings)
|
|
|
|
|
|
def test_energy_density_no_constraint_if_no_provider():
|
|
"""A platform with energy density requirement but no declared provider → no violation."""
|
|
platform = Entity(
|
|
name="Spaceship", dimension="platform",
|
|
dependencies=[
|
|
Dependency("physical", "energy_density_wh_kg", "2000", "Wh/kg", "range_min"),
|
|
],
|
|
)
|
|
# Solar Sail-style: no energy_density_wh_kg declared
|
|
actuator = Entity(
|
|
name="Solar Sail", dimension="actuator",
|
|
dependencies=[
|
|
Dependency("force", "power_density_w_kg", "0.01", "W/kg", "provides"),
|
|
],
|
|
)
|
|
resolver = ConstraintResolver()
|
|
combo = Combination(entities=[platform, actuator])
|
|
result = resolver.resolve(combo)
|
|
density_violations = [v for v in result.violations if "energy density" in v]
|
|
assert len(density_violations) == 0
|