Refactored scripts.

Author: pantierra

.github/workflows/ci.yml

@@ -5,6 +5,13 @@ on:
     branches: [ "main" ]
   pull_request:
     branches: [ "main" ]
+  workflow_dispatch:
+    inputs:
+      debug_enabled:
+        type: boolean
+        description: 'Run with upterm debugging enabled (requires SSH key in secrets)'
+        required: false
+        default: false
 
 env:
   HELM_VERSION: v3.15.2
@@ -27,7 +34,7 @@ jobs:
           version: ${{ env.HELM_VERSION }}
 
       - name: Setup Helm dependencies
-        run: ./scripts/deploy.sh setup
+        run: ./scripts/deploy.sh setup --deps-only
 
       - name: Install ajv-cli
         run: npm install -g ajv-cli ajv-formats
@@ -39,7 +46,7 @@ jobs:
         run: make validate-schema
 
       - name: Run Helm unit tests
-        run: make tests
+        run: make test-helm
 
   integration-tests:
     name: Integration tests
@@ -49,6 +56,16 @@ jobs:
     steps:
       - uses: actions/checkout@v5
 
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install httpx psycopg2-binary pytest
+
       - name: Start K3s cluster
         uses: jupyterhub/action-k3s-helm@v4
         with:
@@ -89,21 +106,91 @@ jobs:
           echo "=== eoAPI Deployment ==="
           export RELEASE_NAME="${RELEASE_NAME}"
           export PGO_VERSION="${{ env.PGO_VERSION }}"
-          export CI_MODE=true
 
-          # Deploy using consolidated script with CI mode
-          ./scripts/deploy.sh --ci
+          # Deploy using consolidated script with ingress enabled for testing (Traefik in K3s)
+          ./scripts/deploy.sh deploy --namespace "${RELEASE_NAME}" --release "${RELEASE_NAME}" \
+            --set ingress.className=traefik \
+            --debug
+
+      - name: Debug session after deployment
+        if: ${{ github.event_name == 'workflow_dispatch' && inputs.debug_enabled }}
+        uses: lhotari/action-upterm@v1
+        with:
+          limit-access-to-keys: ${{ secrets.UPTERM_SSH_KEY }}
+          wait-timeout-minutes: 30
 
       - name: Validate deployment
         run: |
           echo "=== Post-deployment validation ==="
+          export NAMESPACE="${RELEASE_NAME}"
           ./scripts/test.sh check-deployment
 
+      - name: Wait for services to be ready
+        run: |
+          echo "=== Waiting for Services to be Ready ==="
+          kubectl wait --for=condition=available deployment/"${RELEASE_NAME}"-stac -n "${RELEASE_NAME}" --timeout=300s
+          kubectl wait --for=condition=available deployment/"${RELEASE_NAME}"-raster -n "${RELEASE_NAME}" --timeout=300s
+          kubectl wait --for=condition=available deployment/"${RELEASE_NAME}"-vector -n "${RELEASE_NAME}" --timeout=300s
+
+          # Get the K3s node IP for ingress access
+          NODE_IP=$(kubectl get nodes -o jsonpath='{.items[0].status.addresses[?(@.type=="InternalIP")].address}')
+          echo "Node IP: $NODE_IP"
+
+          # Wait for ingress to be ready
+          echo "=== Waiting for Ingress to be Ready ==="
+          kubectl get ingress -n "${RELEASE_NAME}"
+
+          # Wait for Traefik to pick up the ingress rules
+          sleep 10
+
+          # Test connectivity through ingress using node IP
+          echo "=== Testing API connectivity through ingress ==="
+          for i in {1..30}; do
+            if curl -s "http://${NODE_IP}/stac/_mgmt/ping" 2>/dev/null; then
+              echo "✅ STAC API accessible through ingress"
+              break
+            fi
+            echo "Waiting for STAC API... (attempt $i/30)"
+            sleep 3
+          done
+
+          for i in {1..30}; do
+            if curl -s "http://${NODE_IP}/raster/healthz" 2>/dev/null; then
+              echo "✅ Raster API accessible through ingress"
+              break
+            fi
+            echo "Waiting for Raster API... (attempt $i/30)"
+            sleep 3
+          done
+
+          for i in {1..30}; do
+            if curl -s "http://${NODE_IP}/vector/healthz" 2>/dev/null; then
+              echo "✅ Vector API accessible through ingress"
+              break
+            fi
+            echo "Waiting for Vector API... (attempt $i/30)"
+            sleep 3
+          done
+
+          # Export NODE_IP for later steps
+          echo "NODE_IP=$NODE_IP" >> "$GITHUB_ENV"
+
       - name: Run integration tests
         run: |
           export RELEASE_NAME="$RELEASE_NAME"
+          export NAMESPACE="$RELEASE_NAME"
+          export STAC_ENDPOINT="http://${NODE_IP}/stac"
+          export RASTER_ENDPOINT="http://${NODE_IP}/raster"
+          export VECTOR_ENDPOINT="http://${NODE_IP}/vector"
           ./scripts/test.sh integration --debug
 
+      - name: Debug session on test failure
+        if: ${{ github.event_name == 'workflow_dispatch' && inputs.debug_enabled && failure() }}
+        uses: lhotari/action-upterm@v1
+        with:
+          limit-access-to-keys: ${{ secrets.UPTERM_SSH_KEY }}
+          wait-timeout-minutes: 30
+
       - name: Debug failed deployment
         if: failure()
         run: |
@@ -112,8 +199,8 @@ jobs:
       - name: Cleanup
         if: always()
         run: |
-          helm uninstall "$RELEASE_NAME" -n eoapi || true
-          kubectl delete namespace eoapi || true
+          helm uninstall "$RELEASE_NAME" -n "$RELEASE_NAME" || true
+          kubectl delete namespace "$RELEASE_NAME" || true
   validate-docs:
     name: Validate documentation
     runs-on: ubuntu-latest

.github/workflows/tests/test_notifications.py

@@ -115,7 +115,9 @@ def test_cloudevents_sink_logs_show_startup():
         pytest.skip("Cannot get Knative CloudEvents sink logs")
 
     logs = result.stdout
-    assert "listening on port" in logs, "Knative CloudEvents sink should have started successfully"
+    assert "listening on port" in logs, (
+        "Knative CloudEvents sink should have started successfully"
+    )
 
 
 def test_eoapi_notifier_logs_show_connection():

.github/workflows/tests/test_raster.py

@@ -1,7 +1,9 @@
 """test EOapi."""
-import httpx
+
 import os
 
+import httpx
+
 # better timeouts
 timeout = httpx.Timeout(15.0, connect=60.0)
 if bool(os.getenv("IGNORE_SSL_VERIFICATION", False)):
@@ -21,7 +23,10 @@ def test_raster_api(raster_endpoint):
 
 def test_mosaic_api(raster_endpoint):
     """test mosaic."""
-    query = {"collections": ["noaa-emergency-response"], "filter-lang": "cql-json"}
+    query = {
+        "collections": ["noaa-emergency-response"],
+        "filter-lang": "cql-json",
+    }
     resp = client.post(f"{raster_endpoint}/searches/register", json=query)
     assert resp.headers["content-type"] == "application/json"
     assert resp.status_code == 200
@@ -30,7 +35,9 @@ def test_mosaic_api(raster_endpoint):
 
     searchid = resp.json()["id"]
 
-    resp = client.get(f"{raster_endpoint}/searches/{searchid}/point/-85.6358,36.1624/assets")
+    resp = client.get(
+        f"{raster_endpoint}/searches/{searchid}/point/-85.6358,36.1624/assets"
+    )
     assert resp.status_code == 200
     assert len(resp.json()) == 1
     assert list(resp.json()[0]) == ["id", "bbox", "assets", "collection"]
@@ -91,51 +98,87 @@ def test_mosaic_search(raster_endpoint):
     # register some fake mosaic
     searches = [
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection1"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection1"],
+            },
             "metadata": {"owner": "vincent"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection2"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection2"],
+            },
             "metadata": {"owner": "vincent"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection3"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection3"],
+            },
             "metadata": {"owner": "vincent"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection4"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection4"],
+            },
             "metadata": {"owner": "vincent"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection5"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection5"],
+            },
             "metadata": {"owner": "vincent"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection6"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection6"],
+            },
             "metadata": {"owner": "vincent"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection7"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection7"],
+            },
             "metadata": {"owner": "vincent"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection8"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection8"],
+            },
             "metadata": {"owner": "sean"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection9"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection9"],
+            },
             "metadata": {"owner": "sean"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection10"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection10"],
+            },
             "metadata": {"owner": "drew"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection11"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection11"],
+            },
             "metadata": {"owner": "drew"},
         },
         {
-            "filter": {"op": "=", "args": [{"property": "collection"}, "collection12"]},
+            "filter": {
+                "op": "=",
+                "args": [{"property": "collection"}, "collection12"],
+            },
             "metadata": {"owner": "drew"},
         },
     ]
@@ -158,9 +201,16 @@ def test_mosaic_search(raster_endpoint):
 
     links = resp.json()["links"]
     assert len(links) == 2
-    assert links[0]["rel"] == "self"
-    assert links[1]["rel"] == "next"
-    assert links[1]["href"] == f"{raster_endpoint}/searches/list?limit=10&offset=10"
+    # Find links by rel type
+    link_rels = {link["rel"]: link["href"] for link in links}
+    assert "self" in link_rels
+    assert "next" in link_rels
+    # Check if href contains the expected path (works with or without ROOT_PATH)
+    next_href = link_rels["next"]
+    assert (
+        next_href.endswith("/searches/list?limit=10&offset=10")
+        or next_href == f"{raster_endpoint}/searches/list?limit=10&offset=10"
+    )
 
     resp = client.get(
         f"{raster_endpoint}/searches/list", params={"limit": 1, "offset": 1}
@@ -172,34 +222,59 @@ def test_mosaic_search(raster_endpoint):
 
     links = resp.json()["links"]
     assert len(links) == 3
-    assert links[0]["rel"] == "self"
-    assert links[0]["href"] == f"{raster_endpoint}/searches/list?limit=1&offset=1"
-    assert links[1]["rel"] == "next"
-    assert links[1]["href"] == f"{raster_endpoint}/searches/list?limit=1&offset=2"
-    assert links[2]["rel"] == "prev"
-    assert links[2]["href"] == f"{raster_endpoint}/searches/list?limit=1&offset=0"
+    # Find links by rel type
+    link_rels = {link["rel"]: link["href"] for link in links}
+    assert "self" in link_rels
+    assert "next" in link_rels
+    assert "prev" in link_rels
+    # Check if hrefs contain the expected paths (works with or without ROOT_PATH)
+    assert (
+        link_rels["prev"].endswith("/searches/list?limit=1&offset=0")
+        or link_rels["prev"]
+        == f"{raster_endpoint}/searches/list?limit=1&offset=0"
+    )
+    assert (
+        link_rels["self"].endswith("/searches/list?limit=1&offset=1")
+        or link_rels["self"]
+        == f"{raster_endpoint}/searches/list?limit=1&offset=1"
+    )
+    assert (
+        link_rels["next"].endswith("/searches/list?limit=1&offset=2")
+        or link_rels["next"]
+        == f"{raster_endpoint}/searches/list?limit=1&offset=2"
+    )
 
     # Filter on mosaic metadata
-    resp = client.get(f"{raster_endpoint}/searches/list", params={"owner": "vincent"})
+    resp = client.get(
+        f"{raster_endpoint}/searches/list", params={"owner": "vincent"}
+    )
     assert resp.status_code == 200
     assert resp.json()["context"]["matched"] == 7
     assert resp.json()["context"]["limit"] == 10
     assert resp.json()["context"]["returned"] == 7
 
     # sortBy
-    resp = client.get(f"{raster_endpoint}/searches/list", params={"sortby": "lastused"})
+    resp = client.get(
+        f"{raster_endpoint}/searches/list", params={"sortby": "lastused"}
+    )
     assert resp.status_code == 200
 
-    resp = client.get(f"{raster_endpoint}/searches/list", params={"sortby": "usecount"})
+    resp = client.get(
+        f"{raster_endpoint}/searches/list", params={"sortby": "usecount"}
+    )
     assert resp.status_code == 200
 
-    resp = client.get(f"{raster_endpoint}/searches/list", params={"sortby": "-owner"})
+    resp = client.get(
+        f"{raster_endpoint}/searches/list", params={"sortby": "-owner"}
+    )
     assert resp.status_code == 200
     assert (
         "owner" not in resp.json()["searches"][0]["search"]["metadata"]
     )  # some mosaic don't have owners
 
-    resp = client.get(f"{raster_endpoint}/searches/list", params={"sortby": "owner"})
+    resp = client.get(
+        f"{raster_endpoint}/searches/list", params={"sortby": "owner"}
+    )
     assert resp.status_code == 200
     assert "owner" in resp.json()["searches"][0]["search"]["metadata"]