Consolidate test setup (#242)

* Consolidate test setup

The frontend and backend functional tests use completely different deployment
strategies, which complicates maintenance. While the frontend's "podman
compose" mechanism is appealing, it only works with docker *also* installed
as `podman compose` preferentially uses the docker compose engine and the
podman compose engine doesn't function correctly.

Instead, consolidate on a simpified manual podman pod deployment strategy
using a common helper script. I moved some files around to help make this a
bit more consistent and readable: it'd be nice if GitHub were smart enough
to recognize the moved files, but I'm not sure it will.

* Build functional test image early

We use it for the DB init stage, so my local runs used an earlier build but
that doesn't work on CI.

Author: dbutenhof

.github/workflows/frontend-check.yaml

@@ -32,8 +32,8 @@ jobs:
     steps:
       - name: checkout
         uses: actions/checkout@v4
-      - name: enable podman socket to facilitate podman compose
-        run: systemctl --user enable --now podman.socket         
+      # - name: enable podman socket to facilitate podman compose
+      #   run: systemctl --user enable --now podman.socket
       - name: run frontend e2e tests
         run: ./frontend/tests/e2e.sh
       # TODO: add back when the e2e tests capture screenshots

backend/tests/db_seed.py

@@ -10,87 +10,28 @@
 """
 import os
 import time
+import requests
 
-from elasticsearch import Elasticsearch
 import pytest
 
 
 @pytest.fixture(scope="session")
 def server():
     server = os.getenv("SERVER")
     assert server, "SERVER environment variable must be set"
-    return server
-
-
-@pytest.fixture(scope="session", autouse=True)
-def restore_snapshot():
-
-    def indices(db: Elasticsearch) -> set[str]:
-        r = db.indices.get("*")
-        cdm = {i for i in r.keys() if i.startswith("cdmv")}
-        return cdm
-
+    start = time.time()
     ok = False
+    waited = False
     while not ok:
-        time.sleep(5)
         try:
-            start = time.time()
-            db = Elasticsearch("http://localhost:9200")
-            db.cluster.health(wait_for_status="green")
-            print(f"Opensearch claims ready after {time.time()-start:.3f} seconds")
+            requests.get(f"{server}/api/version")
             ok = True
         except Exception as exc:
-            print(f"Opensearch isn't ready: {type(exc).__name__} ({str(exc)!r})")
+            if (time.time() - start) > 60.0:
+                assert False, f"Waited over a minute for server to start: {str(exc)!r})"
+            time.sleep(1.0)
+            waited = True
             continue
-
-        r = db.indices.get("*")
-        cdm = indices(db)
-        if not cdm:
-            try:
-                # Opensearch hasn't been loaded yet, so restore the snapshot
-                print("Restoring 'base' snapshot...")
-                r = db.snapshot.create_repository(
-                    repository="functional",
-                    body={
-                        "type": "fs",
-                        "settings": {"location": "/var/tmp/snapshot"},
-                    },
-                )
-                assert (
-                    r.get("acknowledged") is True
-                ), f"Opensearch didn't create the repository: {r}"
-                r = db.snapshot.get(repository="functional", snapshot="base")
-                # We expect one snapshot, named "base"
-                assert (
-                    r["snapshots"][0]["snapshot"] == "base"
-                ), f"Opensearch didn't find our snapshot: {r}"
-                r = db.snapshot.restore(
-                    repository="functional",
-                    snapshot="base",
-                    request_timeout=20,
-                    body={"indices": "cdmv*dev-*"},
-                    wait_for_completion=True,
-                    master_timeout="60s",
-                )
-                assert (
-                    r["snapshot"]["shards"]["failed"] == 0
-                ), f"Opensearch restore failed: {r}"
-                cdm = indices(db)
-            except Exception as exc:
-                print(
-                    f"Opensearch restore problem: {type(exc).__name__} ({str(exc)!r})"
-                )
-                raise
-        print(f"Restored {len(cdm)} indices: {','.join(cdm)}")
-        time.sleep(2)  # Paranoia: allow stabilization
-
-        # CDM operations assume large "max result window" (maximum number of
-        # returns), although this is mostly important for metric data. Oddly,
-        # the snapshot save/restore seems to end up dropping that setting on
-        # the one specific index where it matters. So just make sure they're
-        # all OK.
-        db.indices.put_settings(body={"index.max_result_window": 262144})
-        hits = db.search(index="cdmv7dev-run")
-        ids = [h["_source"]["run"]["id"] for h in hits["hits"]["hits"]]
-        print(f"Found run IDs {ids} ({len(ids)})")
-        assert len(ids) == 5, "Expected CDM run documents are missing"
+    if waited:
+        print(f"(waited {time.time()-start:0.3f} seconds for server)", end="")
+    return server

backend/tests/functional.containerfile

@@ -1,47 +1,10 @@
 #!/bin/bash
 if [ ${DEBUG} ]; then set -ex ;fi
 
-cleanup () {
-    set +e
-    echo "Cleaning up..."
-    podman pod stop "${POD_NAME}"
-    podman rm "${POD_NAME}-func" "${POD_NAME}-front" "${POD_NAME}-back" "${POD_NAME}-opensearch"
-    podman pod rm "${POD_NAME}"
-}
-
 BRANCH="$(git rev-parse --show-toplevel)"
-BACKEND="${BRANCH}/backend"
-FRONTEND="${BRANCH}/frontend"
-SETUP="${BACKEND}"/tests/functional/setup
-CPT_CONFIG=${CPT_CONFIG:-"${SETUP}/funcconfig.toml"}
-export POD_NAME=${POD_NAME:-FUNC${RANDOM}}
-
-# DEVEL=1 backend/tests/functional/setup/test.sh
-#
-# In "DEVEL" mode, allow external access to the server port, and don't terminate
-# the pod when this script exits.
-if [ ${DEVEL} ]
-then
-    PUBLISH="--publish 127.0.0.1:8000:8000 --publish 127.0.0.1:9200:9200"
-else
-    PUBLISH=""
-    trap cleanup EXIT
-fi
-podman pod create --name=${POD_NAME} ${PUBLISH}
+TESTING="${BRANCH}/testing"
 
-${BACKEND}/scripts/version.py
-podman build -f backend.containerfile --tag backend "${BACKEND}"
-podman build -f frontend.containerfile --tag frontend "${FRONTEND}"
-podman build -f tests/functional/setup/functional.containerfile --tag functional "${BACKEND}"
+. ${TESTING}/pod_setup.sh
+CONTAINERS+=( "${POD_NAME}-func" )
 
-POD="--pod ${POD_NAME}"
-
-"${SETUP}"/opensearch.sh
-podman run -d ${POD} --name="${POD_NAME}-back" -v "${CPT_CONFIG}:/opt/backend/ocpperf.toml:Z" localhost/backend
-podman run -d ${POD} --name="${POD_NAME}-front" localhost/frontend
 podman run ${POD} --name="${POD_NAME}-func" localhost/functional
-
-if [ ${DEVEL} ]
-then
-    echo -e "\n\n--------------\nWhen finished, type\n  podman pod stop ${POD_NAME}\n--------------"
-fi

backend/tests/functional/conftest.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from datetime import datetime, timezone
-import os
 
 import pytest
 import requests
@@ -50,7 +49,7 @@ class Run:
 ]
 
 
-class TestRun:
+class TestIlabRuns:
 
     def test_get_runs(self, server):