Update tests

tests/integration/conftest.py

@@ -34,8 +34,8 @@ from sshecret_sshd.settings import ServerSettings
 from sshecret_sshd.ssh_server import start_sshecret_sshd
 
 from .clients import ClientData
-from .helpers import create_sshd_server_key, create_test_admin_user, in_tempdir
-from .types import PortFactory, TestPorts
+from tests.helpers import create_sshd_server_key, create_test_admin_user, in_tempdir
+from tests.types import PortFactory, TestPorts
 
 TEST_SCOPE = "function"
 LOOP_SCOPE = "function"
@@ -92,7 +92,7 @@ async def run_admin_server(test_ports: TestPorts, backend_server: tuple[str, str
                 "sshecret_backend_url": backend_url,
                 "backend_token": backend_token,
                 "secret_key": secret_key,
-                "listen_address": "127.0.0.1",
+                "listen_address": "0.0.0.0",
                 "port": port,
                 "database": str(admin_db.absolute()),
                 "password_manager_directory": str(admin_work_path.absolute()),

tests/integration/helpers.py

@@ -1,41 +0,0 @@
-"""Helper functions."""
-
-import os
-import tempfile
-from collections.abc import Iterator
-from contextlib import contextmanager
-from pathlib import Path
-from sqlmodel import Session, create_engine
-from sshecret.crypto import generate_private_key, write_private_key
-from sshecret_admin.auth.authentication import hash_password
-from sshecret_admin.auth.models import User, init_db
-from sshecret_admin.core.settings import AdminServerSettings
-
-def create_test_admin_user(settings: AdminServerSettings, username: str, password: str) -> None:
-    """Create a test admin user."""
-    hashed_password = hash_password(password)
-    engine = create_engine(settings.admin_db)
-    init_db(engine)
-    with Session(engine) as session:
-        user = User(username=username, hashed_password=hashed_password)
-        session.add(user)
-        session.commit()
-
-
-def create_sshd_server_key(sshd_path: Path) -> Path:
-    """Create a ssh key at a general"""
-    server_file = sshd_path / "ssh_host_key"
-    private_key = generate_private_key()
-    write_private_key(private_key, server_file)
-    return server_file
-
-
-@contextmanager
-def in_tempdir() -> Iterator[Path]:
-    """Run in a temporary directory."""
-    curdir = os.getcwd()
-    with tempfile.TemporaryDirectory() as temp_directory:
-        temp_path = Path(temp_directory)
-        os.chdir(temp_directory)
-        yield temp_path
-        os.chdir(curdir)

tests/integration/test_admin_api.py

@@ -2,10 +2,13 @@
 
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
+import allure
 import pytest
 
 import httpx
 
+from allure_commons.types import Severity
+
 from sshecret.backend import Client
 
 from sshecret.crypto import generate_private_key, generate_public_key_string
@@ -70,9 +73,12 @@ class BaseAdminTests:
         return client
 
 
+@allure.title("Admin API")
 class TestAdminAPI(BaseAdminTests):
     """Tests of the Admin REST API."""
 
+    @allure.title("Test health test endpoint")
+    @allure.severity(Severity.TRIVIAL)
     @pytest.mark.asyncio
     async def test_health_check(
         self, admin_server: tuple[str, tuple[str, str]]
@@ -82,6 +88,8 @@ class TestAdminAPI(BaseAdminTests):
             resp = await client.get("/health")
             assert resp.status_code == 200
 
+    @allure.title("Test login over API")
+    @allure.severity(Severity.BLOCKER)
     @pytest.mark.asyncio
     async def test_admin_login(self, admin_server: AdminServer) -> None:
         """Test admin login."""
@@ -95,9 +103,12 @@ class TestAdminAPI(BaseAdminTests):
             assert resp.status_code == 200
 
 
+@allure.title("Admin API Client API")
 class TestAdminApiClients(BaseAdminTests):
     """Test client routes."""
 
+    @allure.title("Test creating a client")
+    @allure.description("Ensure we can create a new client.")
     @pytest.mark.asyncio
     async def test_create_client(self, admin_server: AdminServer) -> None:
         """Test create_client."""
@@ -106,6 +117,8 @@ class TestAdminApiClients(BaseAdminTests):
         assert client.id is not None
         assert client.name == "testclient"
 
+    @allure.title("Test reading clients")
+    @allure.description("Ensure we can retrieve a list of current clients.")
     @pytest.mark.asyncio
     async def test_get_clients(self, admin_server: AdminServer) -> None:
         """Test get_clients."""
@@ -124,6 +137,8 @@ class TestAdminApiClients(BaseAdminTests):
                 client_name = entry.get("name")
                 assert client_name in client_names
 
+    @allure.title("Test client deletion")
+    @allure.description("Ensure we can delete a client.")
     @pytest.mark.asyncio
     async def test_delete_client(self, admin_server: AdminServer) -> None:
         """Test delete_client."""
@@ -146,9 +161,12 @@ class TestAdminApiClients(BaseAdminTests):
             assert len(data) == 0
 
 
+@allure.title("Test secret management")
 class TestAdminApiSecrets(BaseAdminTests):
     """Test secret management."""
 
+    @allure.title("Test adding a secret")
+    @allure.description("Ensure that we can add a secret to a client.")
     @pytest.mark.asyncio
     async def test_add_secret(self, admin_server: AdminServer) -> None:
         """Test add_secret."""
@@ -162,6 +180,8 @@ class TestAdminApiSecrets(BaseAdminTests):
             resp = await http_client.post("api/v1/secrets/", json=data)
             assert resp.status_code == 200
 
+    @allure.title("Test read a secret")
+    @allure.description("Ensure that we can retrieve a secret we have stored.")
     @pytest.mark.asyncio
     async def test_get_secret(self, admin_server: AdminServer) -> None:
         """Test get_secret."""
@@ -175,6 +195,8 @@ class TestAdminApiSecrets(BaseAdminTests):
             assert data["secret"] == "secretstring"
             assert "testclient" in data["clients"]
 
+    @allure.title("Test adding a secret with automatic value")
+    @allure.description("Test that we can add a secret where we let the system come up with the value of a given length.")
     @pytest.mark.asyncio
     async def test_add_secret_auto(self, admin_server: AdminServer) -> None:
         """Test adding a secret with an auto-generated value."""
@@ -195,6 +217,8 @@ class TestAdminApiSecrets(BaseAdminTests):
             assert len(data["secret"]) == 17
             assert "testclient" in data["clients"]
 
+    @allure.title("Test updating a secret")
+    @allure.description("Test that we can update the value of a stored secret.")
     @pytest.mark.asyncio
     async def test_update_secret(self, admin_server: AdminServer) -> None:
         """Test updating secrets."""

tests/integration/types.py

@@ -2,25 +2,13 @@
 import asyncssh
 
 from typing import Any, AsyncContextManager, Protocol
-from dataclasses import dataclass
 from collections.abc import Callable, Awaitable
 
 from .clients import ClientData
 
 
-PortFactory = Callable[[], int]
-
 AdminServer = tuple[str, tuple[str, str]]
 
-@dataclass
-class TestPorts:
-    """Test port dataclass."""
-
-    backend: int
-    admin: int
-    sshd: int
-
-
 CommandRunner = Callable[[ClientData, str], Awaitable[asyncssh.SSHCompletedProcess]]
 
 class ProcessRunner(Protocol):