94 lines
4.4 KiB
Python
94 lines
4.4 KiB
Python
import contextlib
|
|
import io
|
|
import json
|
|
from pathlib import Path
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
import coexistence
|
|
import test as runner
|
|
|
|
SPEC = dict(mode="combined", duration_seconds=2, repeats=3, proxy_limit_mbps=100,
|
|
rtt_ms=58, max_slowdown_percent=20)
|
|
|
|
|
|
def fixture(concurrent=1):
|
|
flows = []
|
|
for phase, lane in coexistence.PHASES:
|
|
for direction in ("download", "upload"):
|
|
for repeat in range(1, 4):
|
|
rate = (60 if lane == "mesh" else 100) * (concurrent if phase == "concurrent" else 1)
|
|
flows.append(dict(mode="combined_flow", phase=phase, lane=lane, direction=direction,
|
|
repeat=repeat, bytes=rate * 1e6 / 8 * 2, seconds=2, mbps=rate,
|
|
overlap_ms=1900 if phase == "concurrent" else 0))
|
|
functional = dict(mode="combined_functional", **{k: True for k in coexistence.FLAGS},
|
|
repeats=3, duration_seconds=2, rtt_ms=58, proxy_limit_mbps=100, udp_probes_per_lane=24)
|
|
return flows + [functional]
|
|
|
|
|
|
def log(records):
|
|
return "\n".join(json.dumps(r) for r in records)
|
|
|
|
|
|
class CoexistenceTest(unittest.TestCase):
|
|
def test_complete_results_and_comparisons(self):
|
|
result = coexistence.parse(log(fixture()), SPEC)
|
|
self.assertEqual(len(result["measurements"]), 36)
|
|
self.assertEqual(len(result["summary"]), 12)
|
|
self.assertEqual(len(result["comparisons"]), 12)
|
|
self.assertEqual(result["issues"], [])
|
|
self.assertIn("concurrent_vs_idle", coexistence.markdown(result))
|
|
|
|
def test_rejects_missing_duplicate_and_unfinished_results(self):
|
|
records = fixture()
|
|
for bad in (records[:-1], records[1:], records + [records[0]], []):
|
|
with self.subTest(count=len(bad)), self.assertRaises(ValueError):
|
|
coexistence.parse(log(bad), SPEC)
|
|
|
|
def test_rejects_bad_duration_rate_overlap_and_nonfinite_values(self):
|
|
for replacement in (dict(seconds=.1), dict(mbps=0), dict(bytes=float("nan")),
|
|
dict(mbps=99), dict(overlap_ms=-1)):
|
|
records = fixture()
|
|
records[0].update(replacement)
|
|
with self.subTest(replacement=replacement), self.assertRaises(ValueError):
|
|
coexistence.parse(log(records), SPEC)
|
|
records = fixture()
|
|
next(r for r in records if r.get("phase") == "concurrent")["overlap_ms"] = 100
|
|
with self.assertRaises(ValueError):
|
|
coexistence.parse(log(records), SPEC)
|
|
|
|
def test_requires_fault_checks_config_and_concurrent_udp_evidence(self):
|
|
for replacement in (dict(mesh_survives_proxy_stop=False), dict(proxy_survives_mesh_stop=1),
|
|
dict(repeats=1), dict(udp_probes_per_lane=1), dict(rtt_ms=0)):
|
|
records = fixture()
|
|
records[-1].update(replacement)
|
|
with self.subTest(replacement=replacement), self.assertRaises(ValueError):
|
|
coexistence.parse(log(records), SPEC)
|
|
|
|
def test_slowdown_fails_command_and_preserves_measurements(self):
|
|
step = runner.Step("joint", [sys.executable, "-c", "print(" + repr(log(fixture(.5))) + ")"], measurement=SPEC)
|
|
with tempfile.TemporaryDirectory() as temporary, contextlib.redirect_stdout(io.StringIO()):
|
|
directory = Path(temporary) / "run"
|
|
results = runner.run([step], directory)
|
|
self.assertEqual(results[0]["status"], "failed")
|
|
self.assertIn("slowdown", results[0]["reason"])
|
|
self.assertTrue((directory / "combined-summary.md").exists())
|
|
self.assertEqual(len(json.loads((directory / "combined-metrics.json").read_text())["measurements"]), 36)
|
|
|
|
def test_plan_reuses_native_build_and_rejects_unsupported_platform(self):
|
|
steps = runner.plan(["all", "combined"], native=True, platform="darwin")
|
|
combined = steps[-1]
|
|
self.assertEqual(combined.requires, ("client-go-library",))
|
|
self.assertEqual(combined.env["MESHPORT_JOINT_REPEATS"], "3")
|
|
self.assertNotIn("combined-go-library", [s.name for s in steps])
|
|
with self.assertRaises(ValueError):
|
|
runner.plan(["combined"], platform="linux")
|
|
with contextlib.redirect_stderr(io.StringIO()), self.assertRaises(SystemExit):
|
|
runner.main(["all", "--proxy-mbps", "0", "--list"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|