kleinkram 0.38.1.dev20241212075157__py3-none-any.whl → 0.38.1.dev20250207122632__py3-none-any.whl

testing/backend_fixtures.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from secrets import token_hex
+
+import pytest
+
+from kleinkram import create_mission
+from kleinkram import create_project
+from kleinkram import delete_project
+from kleinkram import list_missions
+from kleinkram import list_projects
+from kleinkram import upload
+
+# we expect the mission files to be in this folder that is not commited to the repo
+DATA_PATH = Path(__file__).parent.parent / "data" / "testing"
+DATA_FILES = [
+    DATA_PATH / "10_KB.bag",
+    DATA_PATH / "50_KB.bag",
+    DATA_PATH / "1_MB.bag",
+    DATA_PATH / "17_MB.bag",
+    DATA_PATH / "125_MB.bag",
+]
+
+PROJECT_DESCRIPTION = "This is a test project"
+
+
+WAIT_BEOFORE_DELETION = 5
+
+
+@pytest.fixture(scope="session")
+def project():
+    project_name = token_hex(8)
+
+    print("here")
+    create_project(project_name, description="This is a test project")
+
+    project = list_projects(project_names=[project_name])[0]
+
+    yield project
+
+    time.sleep(WAIT_BEOFORE_DELETION)
+    delete_project(project.id)
+
+
+@pytest.fixture
+def mission(project):
+    mission_name = token_hex(8)
+    upload(
+        mission_name=mission_name,
+        project_id=project.id,
+        files=DATA_FILES,
+        create=True,
+    )
+    mission = list_missions(project_ids=[project.id], mission_names=[mission_name])[0]
+
+    yield mission
+
+
+@pytest.fixture
+def empty_mission(project):
+    mission_name = token_hex(8)
+    create_mission(mission_name, project.id, metadata={})
+    mission = list_missions(project_ids=[project.id], mission_names=[mission_name])[0]
+
+    yield mission

tests/conftest.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+import pytest
+
+pytest_plugins = [
+    "testing.backend_fixtures",
+]

tests/test_config.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import pytest
+
+from kleinkram.config import Config
+from kleinkram.config import Endpoint
+from kleinkram.config import _load_config
+from kleinkram.config import add_endpoint
+from kleinkram.config import check_config_compatibility
+from kleinkram.config import endpoint_table
+from kleinkram.config import get_config
+from kleinkram.config import get_env
+from kleinkram.config import get_shared_state
+from kleinkram.config import save_config
+from kleinkram.config import select_endpoint
+
+CONFIG_FILENAME = "kleinkram.json"
+
+
+@pytest.fixture
+def config_path():
+    with TemporaryDirectory() as tmpdir:
+        yield Path(tmpdir) / CONFIG_FILENAME
+
+
+def test_load_config_default(config_path):
+    config = _load_config(path=config_path)
+
+    assert not config_path.exists()
+    assert Config() == config
+
+
+def test_save_and_load_config(config_path):
+
+    config = Config(version="foo")
+
+    assert not config_path.exists()
+    save_config(config, path=config_path)
+    assert config_path.exists()
+
+    loaded_config = _load_config(path=config_path)
+    assert loaded_config == config
+
+
+def test_get_config_default(config_path):
+    config = get_config(path=config_path)
+
+    assert not config_path.exists()
+    assert Config() == config
+    assert config is get_config(path=config_path)
+
+
+def test_get_config_after_save(config_path):
+    config = get_config(path=config_path)
+    config.version = "foo"
+    save_config(config, path=config_path)
+
+    assert config is get_config(path=config_path)
+
+
+def test_get_shared_state():
+    state = get_shared_state()
+    assert state is get_shared_state()
+
+
+def test_select_endpoint(config_path):
+    config = get_config(path=config_path)
+    save_config(config, path=config_path)
+    assert config.selected_endpoint == get_env().value
+
+    # select existing endpoint
+    select_endpoint(config, "prod", path=config_path)
+    assert config.selected_endpoint == "prod"
+    assert config == _load_config(path=config_path)
+
+    with pytest.raises(ValueError):
+        select_endpoint(config, "foo", path=config_path)
+
+
+def test_add_endpoint(config_path):
+    config = get_config(path=config_path)
+    save_config(config, path=config_path)
+    assert config.selected_endpoint == get_env().value
+
+    with pytest.raises(ValueError):
+        select_endpoint(config, "foo", path=config_path)
+
+    ep = Endpoint("foo", "api", "s3")
+    add_endpoint(config, ep, path=config_path)
+    assert config.selected_endpoint == "foo"
+    assert config.endpoint == ep
+    assert config == _load_config(path=config_path)
+
+    select_endpoint(config, "dev", path=config_path)
+    assert config.selected_endpoint == "dev"
+    select_endpoint(config, "foo", path=config_path)
+    assert config.selected_endpoint == "foo"
+
+
+def test_endpoint_table():
+    config = Config()
+    table = endpoint_table(config)
+
+    assert [c.header for c in table.columns] == ["Name", "API", "S3"]
+    assert len(table.rows) == 3
+
+
+def test_check_config_compatiblity(config_path):
+    assert check_config_compatibility(path=config_path)
+    with open(config_path, "w") as f:
+        f.write("foo")  # invalid config
+    assert not check_config_compatibility(path=config_path)

tests/test_core.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from secrets import token_hex
+from uuid import uuid4
+
+import pytest
+
+import kleinkram.api.routes
+import kleinkram.core
+import kleinkram.errors
+from kleinkram import list_files
+from kleinkram import list_missions
+from kleinkram import list_projects
+from kleinkram.api.client import AuthenticatedClient
+from kleinkram.api.query import FileQuery
+from kleinkram.api.query import MissionQuery
+from kleinkram.api.query import ProjectQuery
+from kleinkram.errors import MissionNotFound
+from kleinkram.models import FileVerificationStatus
+from testing.backend_fixtures import DATA_FILES
+
+
+@pytest.mark.slow
+def test_upload_create(project):
+    mission_name = token_hex(8)
+    mission_query = MissionQuery(
+        patterns=[mission_name], project_query=ProjectQuery(ids=[project.id])
+    )
+
+    client = AuthenticatedClient()
+    kleinkram.core.upload(
+        client=client, query=mission_query, file_paths=DATA_FILES, create=True
+    )
+
+    mission = list_missions(mission_names=[mission_name])[0]
+    assert mission.project_id == project.id
+    assert mission.name == mission_name
+
+    files = list_files(mission_ids=[mission.id])
+    assert set([file.name for file in files if file.name.endswith(".bag")]) == set(
+        [file.name for file in DATA_FILES]
+    )
+
+
+@pytest.mark.slow
+def test_upload_no_create(project):
+    mission_name = token_hex(8)
+    mission_query = MissionQuery(
+        patterns=[mission_name], project_query=ProjectQuery(ids=[project.id])
+    )
+
+    client = AuthenticatedClient()
+    with pytest.raises(MissionNotFound):
+        kleinkram.core.upload(
+            client=client, query=mission_query, file_paths=DATA_FILES, create=False
+        )
+
+
+@pytest.mark.slow
+def test_upload_to_existing_mission(empty_mission):
+    mission_query = MissionQuery(ids=[empty_mission.id])
+
+    client = AuthenticatedClient()
+    kleinkram.core.upload(client=client, query=mission_query, file_paths=DATA_FILES)
+
+    files = list_files(mission_ids=[empty_mission.id])
+    assert set([file.name for file in files if file.name.endswith(".bag")]) == set(
+        [file.name for file in DATA_FILES]
+    )
+
+
+@pytest.mark.slow
+def test_delete_existing_files(mission):
+    client = AuthenticatedClient()
+    files = list_files(mission_ids=[mission.id], file_names=["*.bag"])
+    kleinkram.core.delete_files(client=client, file_ids=[f.id for f in files])
+    assert not list_files(mission_ids=[mission.id], file_names=["*.bag"])
+
+
+@pytest.mark.slow
+def test_delete_non_existing_files():
+    client = AuthenticatedClient()
+
+    with pytest.raises(kleinkram.errors.FileNotFound):
+        kleinkram.core.delete_files(client=client, file_ids=[uuid4()])
+
+
+@pytest.mark.slow
+def test_create_update_delete_mission(project):
+    mission_name = token_hex(8)
+
+    client = AuthenticatedClient()
+    kleinkram.api.routes._create_mission(client, project.id, mission_name)
+
+    mission = list_missions(mission_names=[mission_name])[0]
+
+    assert mission.project_id == project.id
+    assert mission.name == mission_name
+
+    assert list_files(mission_ids=[mission.id]) == []
+
+    # TODO test update, for this we would need to add metadata types to the backend
+
+    kleinkram.core.delete_mission(client=client, mission_id=mission.id)
+
+
+@pytest.mark.slow
+def test_create_update_delete_project():
+    project_name = token_hex(8)
+
+    client = AuthenticatedClient()
+    project_id = kleinkram.api.routes._create_project(client, project_name, "test")
+    project = list_projects(project_ids=[project_id])[0]
+
+    assert list_missions(project_ids=[project.id]) == []
+    assert list_files(project_ids=[project.id]) == []
+
+    assert project.name == project_name
+    assert project.description == "test"
+
+    new_name = token_hex(8)
+    kleinkram.core.update_project(
+        client=client, project_id=project.id, new_name=new_name, description="new desc"
+    )
+
+    project = list_projects(project_ids=[project.id])[0]
+    assert project.name == new_name
+    assert project.description == "new desc"
+
+    kleinkram.core.delete_project(client=client, project_id=project.id)
+
+
+@pytest.mark.slow
+def test_download(mission, tmp_path):
+    client = AuthenticatedClient()
+
+    query = FileQuery(mission_query=MissionQuery(ids=[mission.id]), patterns=["*.bag"])
+    kleinkram.core.download(client=client, query=query, base_dir=tmp_path)
+    files = list_files(mission_ids=[mission.id], file_names=["*.bag"])
+
+    assert set([f.name for f in tmp_path.iterdir()]) == set([f.name for f in files])
+
+    for file in files:
+        assert (tmp_path / file.name).stat().st_size == file.size
+
+
+@pytest.mark.slow
+def test_verify(mission):
+    client = AuthenticatedClient()
+    query = MissionQuery(ids=[mission.id])
+
+    verify_status = kleinkram.core.verify(
+        client=client, query=query, file_paths=DATA_FILES, skip_hash=True
+    )
+
+    assert all(
+        status == FileVerificationStatus.UPLAODED for status in verify_status.values()
+    )
+
+
+@pytest.mark.slow
+def test_update_file():
+    client = AuthenticatedClient()
+    with pytest.raises(NotImplementedError):
+        kleinkram.core.update_file(client=client, file_id=uuid4())

tests/test_end_to_end.py

@@ -6,18 +6,16 @@ import shutil
 from pathlib import Path
 
 import pytest
-from kleinkram.api.routes import _get_api_version
 from rich.console import Console
 from rich.text import Text
 
+from kleinkram.api.routes import _get_api_version
+
 VERBOSE = True
 
 CLI = "klein"
 PROJECT_NAME = "automated-testing"
-
-DATA_DIR = Path(__file__).parent.parent / "data" / "testing"
-_IN_DIR = DATA_DIR / "in"
-_OUT_DIR = DATA_DIR / "out"
+DATA_PATH = Path(__file__).parent.parent / "data" / "testing"
 
 
 @pytest.fixture(scope="session")
@@ -30,25 +28,6 @@ def api():
         return False
 
 
-@pytest.fixture(scope="session")
-def in_dir():
-    return _IN_DIR
-
-
-@pytest.fixture(scope="session")
-def out_dir():
-    try:
-        _OUT_DIR.mkdir(exist_ok=True)
-        yield _OUT_DIR
-    finally:
-        shutil.rmtree(_OUT_DIR)
-
-
-@pytest.fixture(scope="session")
-def name():
-    return secrets.token_hex(8)
-
-
 def run_cmd(command, *, verbose=VERBOSE):
     msg = ("\n", "#" * 50, "\n\n", "running command:", Text(command, style="bold"))
     Console().print(*msg)
@@ -61,45 +40,56 @@ def run_cmd(command, *, verbose=VERBOSE):
 
 
 @pytest.mark.slow
-def test_upload_verify_update_download_mission(name, in_dir, out_dir, api):
+def test_upload_verify_update_download_mission(project, tmp_path, api):
     assert api
 
-    upload = (
-        f"{CLI} upload -p {PROJECT_NAME} -m {name} --create {in_dir.absolute()}/*.bag"
+    mission_name = secrets.token_hex(8)
+    upload = f"{CLI} upload -p {project.name} -m {mission_name} --create {DATA_PATH.absolute()}/*.bag"
+    verify = (
+        f"{CLI} verify -p {project.name} -m {mission_name} {DATA_PATH.absolute()}/*.bag"
     )
-    verify = f"{CLI} verify -p {PROJECT_NAME} -m {name} {in_dir.absolute()}/*.bag"
-    update = f"{CLI} mission update -p {PROJECT_NAME} -m {name} --metadata {in_dir.absolute()}/metadata.yaml"
-    download = f"{CLI} download -p {PROJECT_NAME} -m {name} --dest {out_dir.absolute()}"
+    # update = f"{CLI} mission update -p {project.name} -m {mission_name} --metadata {DATA_PATH.absolute()}/metadata.yaml"
+    download = f"{CLI} download -p {project.name} -m {mission_name} --dest {tmp_path.absolute()}"
 
     assert run_cmd(upload) == 0
     assert run_cmd(verify) == 0
-    assert run_cmd(update) == 0
+    # assert run_cmd(update) == 0
     assert run_cmd(download) == 0
 
 
 @pytest.mark.slow
-def test_list_files(api):
+def test_list_files(project, mission, api):
     assert api
-    assert run_cmd(f"{CLI} list files -p {PROJECT_NAME}") == 0
-    assert run_cmd(f"{CLI} list files -p {PROJECT_NAME} -m {secrets.token_hex(8)}") == 0
+    assert run_cmd(f"{CLI} list files -p {project.name}") == 0
+    assert run_cmd(f"{CLI} list files -p {project.name} -m {mission.name}") == 0
     assert run_cmd(f"{CLI} list files") == 0
-    assert run_cmd(f"{CLI} list files -p {secrets.token_hex(8)}") == 0
+    assert run_cmd(f"{CLI} list files -p {mission.name}") == 0
     assert run_cmd(f'{CLI} list files -p "*" -m "*" "*"') == 0
 
 
 @pytest.mark.slow
-def test_list_missions(api):
+def test_list_missions(api, project, mission):
     assert api
-    assert run_cmd(f"{CLI} list missions -p {PROJECT_NAME}") == 0
+
+    assert run_cmd(f"{CLI} list missions -p {project.name} {mission.name}") == 0
+    assert run_cmd(f"{CLI} list missions -p {project.name} {secrets.token_hex(8)}") == 0
+    assert run_cmd(f"{CLI} list missions -p {project.name} {mission.id}") == 0
+    assert run_cmd(f"{CLI} list missions {secrets.token_hex(8)}") == 0
+    assert run_cmd(f"{CLI} list missions {mission.id}") == 0
+    assert run_cmd(f"{CLI} list missions {mission.name}") == 0
+
+    assert run_cmd(f"{CLI} list missions -p {project.name}") == 0
+    assert run_cmd(f"{CLI} list missions -p {project.id}") == 0
     assert run_cmd(f"{CLI} list missions -p {secrets.token_hex(8)}") == 0
     assert run_cmd(f"{CLI} list missions") == 0
     assert run_cmd(f'{CLI} list missions -p "*" "*"') == 0
 
 
 @pytest.mark.slow
-def test_list_projects(api):
+def test_list_projects(api, project):
     assert api
     assert run_cmd(f"{CLI} list projects") == 0
-    assert run_cmd(f"{CLI} list projects {PROJECT_NAME}") == 0
+    assert run_cmd(f"{CLI} list projects {project.name}") == 0
     assert run_cmd(f"{CLI} list projects {secrets.token_hex(8)}") == 0
+    assert run_cmd(f"{CLI} list projects {project.id}") == 0
     assert run_cmd(f'{CLI} list projects "*"') == 0

tests/test_error_handling.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import pytest
+
+from kleinkram.cli.error_handling import display_error
+
+
+class MyException(Exception):
+    pass
+
+
+def test_display_error_not_verbose(capsys):
+    exc = MyException("hello")
+
+    display_error(exc=exc, verbose=False)
+
+    out, err = capsys.readouterr()
+
+    assert out == ""
+    assert err == "MyException: hello\n"
+
+    exc = MyException()
+
+    display_error(exc=exc, verbose=False)
+
+    out, err = capsys.readouterr()
+
+    assert out == ""
+    assert err == "MyException\n"
+
+
+def test_display_error_verbose(capsys):
+    exc = MyException("hello")
+
+    display_error(exc=exc, verbose=True)
+
+    out, err = capsys.readouterr()
+
+    assert out == ""
+    assert err == (
+        "╭──────────────────────────────── My Exception ────────────────────────────────╮\n"
+        "│ hello                                                                        │\n"
+        "╰──────────────────────────────────────────────────────────────────────────────╯\n"
+    )

tests/test_fixtures.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import pytest
+
+from kleinkram import list_files
+from kleinkram import list_missions
+from kleinkram import list_projects
+from testing.backend_fixtures import DATA_FILES
+from testing.backend_fixtures import PROJECT_DESCRIPTION
+
+
+@pytest.mark.slow
+def test_project_fixture(project):
+    assert list_projects(project_ids=[project.id])[0].id == project.id
+    assert project.description == PROJECT_DESCRIPTION
+
+
+@pytest.mark.slow
+def test_mission_fixture(mission, project):
+    assert mission.project_id == project.id
+    assert list_missions(mission_ids=[mission.id])[0].id == mission.id
+
+    files = list_files(mission_ids=[mission.id])
+
+    assert set([file.name for file in files if file.name.endswith(".bag")]) == set(
+        [file.name for file in DATA_FILES]
+    )
+
+
+@pytest.mark.slow
+def test_empty_mission_fixture(empty_mission, project):
+    assert empty_mission.project_id == project.id
+    assert list_missions(mission_ids=[empty_mission.id])[0].id == empty_mission.id
+    assert not list_files(mission_ids=[empty_mission.id])

tests/test_printing.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import datetime
+
+import pytest
+
+from kleinkram.models import MetadataValue
+from kleinkram.models import MetadataValueType
+from kleinkram.printing import format_bytes
+from kleinkram.printing import parse_metadata_value
+
+
+def test_format_bytes():
+    assert format_bytes(0) == "0 B"
+    assert format_bytes(1) == "1 B"
+    assert format_bytes(1000) == "1000 B"
+    assert format_bytes(1024) == "1.00 KB"
+    assert format_bytes(1025) == "1.00 KB"
+    assert format_bytes(2048) == "2.00 KB"
+    assert format_bytes(2**20) == "1.00 MB"
+    assert format_bytes(2**30) == "1.00 GB"
+    assert format_bytes(2**40) == "1.00 TB"
+    assert format_bytes(2**50) == "1.00 PB"
+
+
+def test_parse_metadata_value():
+    mv = MetadataValue(type_=MetadataValueType.STRING, value="foo")
+    assert parse_metadata_value(mv) == "foo"
+    mv = MetadataValue(type_=MetadataValueType.LINK, value="foo")
+    assert parse_metadata_value(mv) == "foo"
+    mv = MetadataValue(type_=MetadataValueType.LOCATION, value="foo")
+    assert parse_metadata_value(mv) == "foo"
+    mv = MetadataValue(type_=MetadataValueType.NUMBER, value="1")
+    assert parse_metadata_value(mv) == 1.0
+    mv = MetadataValue(type_=MetadataValueType.BOOLEAN, value="true")
+    assert parse_metadata_value(mv) is True  # noqa
+    mv = MetadataValue(type_=MetadataValueType.BOOLEAN, value="false")
+    assert parse_metadata_value(mv) is False  # noqa
+    mv = MetadataValue(type_=MetadataValueType.DATE, value="2021-01-01T00:00:00Z")
+    assert parse_metadata_value(mv) == datetime.datetime(
+        2021, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+    )
+
+
+@pytest.mark.skip
+def test_projects_to_table(): ...
+
+
+@pytest.mark.skip
+def test_missions_to_table(): ...
+
+
+@pytest.mark.skip
+def test_files_to_table(): ...
+
+
+@pytest.mark.skip
+def test_mission_info_table(): ...
+
+
+@pytest.mark.skip
+def test_project_info_table(): ...