Big update, AppVeyor_Test

tests/conftest.py

@@ -0,0 +1,120 @@
+import pytest
+import random
+import csv
+from tempfile import mkstemp
+from pathlib import Path
+
+
+def get_mult(star_type):
+    if star_type.startswith("Neutron"):
+        return 4.0
+    if star_type.startswith("White Dwarf"):
+        return 1.5
+    return 1.0
+
+
+def gen_pos(p_distrib):
+    p = []
+    for v in p_distrib:
+        v = random.triangular(-v, v)
+        p.append(v)
+    return p
+
+
+def make_stars(num, p_distrib):
+    star_types = [
+        "A (Blue-White) Star",
+        "A (Blue-White super giant) Star",
+        "B (Blue-White) Star",
+        "B (Blue-White super giant) Star",
+        "Black Hole",
+        "CJ Star",
+        "CN Star",
+        "C Star",
+        "F (White) Star",
+        "F (White super giant) Star",
+        "G (White-Yellow) Star",
+        "G (White-Yellow super giant) Star",
+        "Herbig Ae/Be Star",
+        "K (Yellow-Orange giant) Star",
+        "K (Yellow-Orange) Star",
+        "L (Brown dwarf) Star",
+        "M (Red dwarf) Star",
+        "M (Red giant) Star",
+        "M (Red super giant) Star",
+        "MS-type Star",
+        "Neutron Star",
+        "O (Blue-White) Star",
+        "star_type",
+        "S-type Star",
+        "Supermassive Black Hole",
+        "T (Brown dwarf) Star",
+        "T Tauri Star",
+        "White Dwarf (DAB) Star",
+        "White Dwarf (DA) Star",
+        "White Dwarf (DAV) Star",
+        "White Dwarf (DAZ) Star",
+        "White Dwarf (DB) Star",
+        "White Dwarf (DBV) Star",
+        "White Dwarf (DBZ) Star",
+        "White Dwarf (DC) Star",
+        "White Dwarf (DCV) Star",
+        "White Dwarf (DQ) Star",
+        "White Dwarf (D) Star",
+        "Wolf-Rayet C Star",
+        "Wolf-Rayet NC Star",
+        "Wolf-Rayet N Star",
+        "Wolf-Rayet O Star",
+        "Wolf-Rayet Star",
+        "Y (Brown dwarf) Star",
+    ]
+    id_n = 0
+    while id_n < num:
+        name = "System {}".format(id_n)
+        body = "System {} Star {}".format(id_n, 0)
+        distance = 0
+        star_type = random.choice(star_types)
+        mult = get_mult(star_type)
+        x, y, z = gen_pos(p_distrib)
+        s_type = random.choice(star_types)
+        record = [id_n, s_type, name, body, mult, distance]
+        record.extend((x, y, z))
+        yield record
+        id_n += 1
+        for sub_id in range(random.randint(0, 4)):
+            star_type = random.choice(star_types)
+            mult = get_mult(star_type)
+            distance = random.randint(100, 10000)
+            body = "System {} Star {}".format(id_n, sub_id + 1)
+            s_type = random.choice(star_types)
+            record = [id_n, s_type, name, body, mult, distance]
+            record.extend((x, y, z))
+            yield record
+            id_n += 1
+
+
+@pytest.fixture(scope="module")
+def stars_path():
+    num_stars = int(1e7)
+    p_distrib = [5000, 5000, 500]
+    tmpfile, filename = mkstemp(suffix=".csv", prefix="stars_", text=True)
+    filename = Path(filename)
+    tmpfile = open(tmpfile, "w", encoding="utf-8")
+    fields = ["id", "star_type", "system", "body", "mult"]
+    fields += ["distance", "x", "y", "z"]
+    csv_writer = csv.DictWriter(tmpfile, fields)
+    rows = (dict(zip(fields, row)) for row in make_stars(num_stars, p_distrib))
+    csv_writer.writeheader()
+    csv_writer.writerows(rows)
+    tmpfile.close()
+    while True:
+        sys_ids = random.choices(range(num_stars), k=10)
+        if len(set(sys_ids)) == len(sys_ids):
+            break
+    rand_sys = list(map("System {}".format, sys_ids))
+    yield str(filename.resolve()), rand_sys
+    if filename.exists():
+        filename.unlink()
+    idx = filename.with_suffix(".idx")
+    if idx.exists():
+        idx.unlink()

tests/test_benchmark.py

@@ -0,0 +1,45 @@
+import pytest
+import os
+from math import log2, ceil
+
+
+def resolve_systems(r, *names):
+    ret = []
+    mapping = r.resolve_systems(*names)
+    for name in names:
+        ret.append(mapping.get(name))
+    return ret
+
+
+@pytest.fixture(scope="module")
+def ed_lrr_router(stars_path):
+    stars_path, systems = stars_path
+    from ed_lrr_gui import PyRouter
+
+    r = PyRouter(lambda status: None)
+    r.load(stars_path)
+    system_ids = resolve_systems(r, *systems)
+    return r, system_ids
+
+
+argvalues = [(0, 0)]
+argvalues += [(2 ** n, 0) for n in range(17)]
+argvalues += [(0, g) for g in (0.25, 0.5, 0.75, 1)]
+ids = []
+for width, greedyness in argvalues:
+    ids.append("beam_width:{}-greedyness:{}".format(width, greedyness))
+
+n_workers = [0]
+n_workers += [2**n for n in range(ceil(log2(os.cpu_count()))+1)]
+
+
+@pytest.mark.parametrize("workers", n_workers,
+                         ids=lambda v: "workers:{}".format(v))
+@pytest.mark.parametrize(argnames=("width", "greedyness"),
+                         argvalues=argvalues, ids=ids)
+@pytest.mark.parametrize("r_range", [48.0], ids=lambda v: "range:{}".format(v))
+def test_benchmark(benchmark, ed_lrr_router,
+                   r_range, workers, greedyness, width):
+    r, system_ids = ed_lrr_router
+    args = system_ids, r_range, greedyness, width, workers
+    benchmark(r.route, *args)

tests/test_ed_lrr.py

@@ -1,24 +1,78 @@
+# -*- coding: utf-8 -*-
+import random
 import pytest
-
-stars_csv = "D:\\devel\\rust\\ED_LRR\\stars.csv"
+import os
+from flaky import flaky
 
 
-@pytest.mark.dependency()
-def test_import():
-    import _ed_lrr
+if not hasattr(random, "choices"):
+
+    def choices(population, *, k=1):
+        return [random.choice(population) for _ in range(k)]
+
+    random.choices = choices
 
 
-@pytest.mark.dependency(depends=["test_import"])
-def test_search_works():
-    import _ed_lrr
+@pytest.fixture(scope="module")
+def py_router(stars_path):
+    from ed_lrr_gui import PyRouter
 
-    system_names = ["Ix", "Sol", "Colonia", "Sagittarius A*"]
-    systems = _ed_lrr.find_sys(system_names, stars_csv)
-    print(systems)
+    stars_path, names = stars_path
+    router = PyRouter(lambda status: None)
+    router.load(stars_path)
+    resolved_systems = router.resolve_systems(*names)
+    for name in names:
+        err = "Failed to resolve {}".format(name)
+        assert name in resolved_systems, err
+    yield router, resolved_systems
 
 
-@pytest.mark.dependency(depends=["test_import"])
-def test_zero_range_fails():
-    import _ed_lrr
+class Test_ED_LRR(object):  # noqa: H601
+    @pytest.mark.dependency()
+    @flaky(max_runs=10, min_passes=5)
+    def test_load_and_resolve(self, stars_path):
+        stars_path, names = stars_path
+        from ed_lrr_gui import PyRouter
 
-    # _ed_lrr.route()
+        router = PyRouter(lambda status: None)
+        router.load(stars_path)
+        resolved_systems = router.resolve_systems(*names)
+        for name in names:
+            err = "Failed to resolve {}".format(name)
+            assert name in resolved_systems, err
+
+    @pytest.mark.dependency(depends=["Test_ED_LRR::test_load_and_resolve"])
+    @flaky(max_runs=10, min_passes=5)
+    def test_zero_range_fails(self, py_router):
+        r, resolved_systems = py_router
+        waypoints = random.choices(list(resolved_systems.values()), k=2)
+        err = pytest.raises(RuntimeError, r.route, waypoints, 0)
+        err.match(r"No route from .* to .* found!")
+
+    beam_widths = [256, 512, 1024, 0]
+    greedyness = [0, 0.5, 1]
+    n_workers = [0, os.cpu_count()]
+    ranges = [30, 50]
+
+    @pytest.mark.dependency(depends=["Test_ED_LRR::test_load_and_resolve"])
+    @flaky(max_runs=10, min_passes=2)
+    @pytest.mark.parametrize("workers", n_workers,
+                             ids=lambda v: "workers:{}".format(v))
+    @pytest.mark.parametrize("jump_range", ranges,
+                             ids=lambda v: "range:{}".format(v))
+    @pytest.mark.parametrize(
+        "greedyness", greedyness, ids=lambda v: "greedyness:{}".format(v)
+    )
+    @pytest.mark.parametrize(
+        "beam_width", beam_widths, ids=lambda v: "beam_width:{}".format(v)
+    )
+    def test_route(self, py_router, jump_range,
+                   workers, greedyness, beam_width):
+        r, resolved_systems = py_router
+        waypoints = random.choices(list(resolved_systems.values()), k=2)
+        args = waypoints, jump_range, greedyness, beam_width, workers
+        err = "Failed to route for waypoints: {}".format(waypoints)
+        route_len = r.route(*args)
+        assert route_len != 0, err
+        del r
+        # TODO: verify hop distance and inclusion of waypoints

tests/test_gui.py

@@ -1,18 +1,22 @@
-import pytest
+# -*- coding: utf-8 -*-
+# import pytest
 
 
-@pytest.mark.dependency()
-def test_import():
-    import ed_lrr_gui
-    from ed_lrr_gui.main import main
-    import ed_lrr_gui.gui as ED_LRR_GUI
+# class Test_GUI(object):
+#     pass
+
+# @pytest.mark.dependency()
+# def test_import():
+#     import ed_lrr_gui
+#     from ed_lrr_gui.main import main
+#     import ed_lrr_gui.gui as ED_LRR_GUI
 
 
-@pytest.mark.dependency(depends=["test_import"])
-def test_search_works():
-    import ed_lrr_gui
+# @pytest.mark.dependency(depends=["test_import"])
+# def test_search_works():
+#     import ed_lrr_gui
 
 
-@pytest.mark.dependency(depends=["test_import"])
-def test_zero_range_fails():
-    import ed_lrr_gui
+# @pytest.mark.dependency(depends=["test_import"])
+# def test_zero_range_fails():
+#     import ed_lrr_gui

tests/test_web.py

@@ -0,0 +1,21 @@
+import pytest
+
+
+@pytest.fixture
+def app():
+    from ed_lrr_gui.web import app as flask_app
+    yield flask_app
+
+
+@pytest.fixture
+def db():
+    from ed_lrr_gui.web import db as flask_db
+    yield flask_db
+
+
+class Test_DB(object):  # noqa: H601
+    pass
+
+
+class Test_Webapp(object):  # noqa: H601
+    pass