Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

ci(platform): cache the e2e seed dump in GHCR instead of the Actions cache (#15983)

Bentlyee41e2822c4c
diff --git a/.github/scripts/test_e2e_seed_cache_contract.py b/.github/scripts/test_e2e_seed_cache_contract.py
index 6c88fd1918..c21fa538c6 100644
--- a/.github/scripts/test_e2e_seed_cache_contract.py
+++ b/.github/scripts/test_e2e_seed_cache_contract.py
@@ -1,8 +1,42 @@
-import fnmatch
+import os
import re
+import subprocess
+import tempfile
import unittest
from pathlib import Path
+SEED_KEY_STEP = "Set up tests - Compute E2E test data cache key"
+SEED_PULL_STEP = "Set up tests - Pull cached E2E test data from GHCR"
+SEED_RESTORE_STEP = "Set up tests - Load cached E2E test data"
+SEED_CREATE_STEP = "Set up tests - Create E2E test data"
+SEED_VERIFY_STEP = "Set up tests - Verify seeded credentials with fresh encryption key"
+SEED_SAVE_STEP = "Push E2E test data to GHCR"
+PLAYWRIGHT_STEP = "Run Playwright E2E suite"
+PLAYWRIGHT_REPORT_STEP = "Validate Playwright JSON report"
+# What the seed prints once every item has an embedding.
+EMBEDDINGS_COMPLETE = "Embeddings complete:"
+# Backend modules whose functions the seed calls to write rows into the dump.
+# The dump's encrypted payloads are re-encrypted on every run, so the
+# encryption module is not one of them.
+SEED_WRITERS = (
+ "api/features/library/db",
+ "api/features/library/model",
+ "api/features/orgs/db",
+ "api/features/search/embeddings",
+ "api/features/store/db",
+ "data/auth/api_key",
+ "data/credit",
+ "data/graph",
+ "data/org_migration",
+ "data/profile",
+ "data/user",
+ "util/json",
+)
+
+
+def _step(workflow: str, name: str) -> str:
+ return workflow.split(f"- name: {name}\n", 1)[1].split("\n - name:", 1)[0]
+
def _matrix_leg(workflow: str, suite: str) -> dict[str, str]:
e2e_job = workflow.split("\n e2e_test:\n", 1)[1].split("\n steps:\n", 1)[0]
@@ -15,10 +49,7 @@ class E2EMatrixContractTests(unittest.TestCase):
workflow = (
Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
).read_text(encoding="utf-8")
- key = next(
- line for line in workflow.splitlines() if "key: e2e-test-data-" in line
- )
- self.assertIn("matrix.embeddings", key)
+ self.assertIn("matrix.embeddings", _step(workflow, SEED_KEY_STEP))
self.assertEqual(_matrix_leg(workflow, "smoke")["embeddings"], "true")
self.assertEqual(_matrix_leg(workflow, "journeys")["embeddings"], "false")
@@ -78,13 +109,15 @@ class E2ESeedCacheContractTests(unittest.TestCase):
)
self.assertEqual(_matrix_leg(workflow, "smoke")["seed"], "true")
self.assertNotIn("continue-on-error", verification)
+ # The trailing newline matters: the key step's sed names the create
+ # step too, earlier in the file.
self.assertLess(
- workflow.index("- name: Set up tests - Create E2E test data"),
- workflow.index(f"- name: {name}"),
+ workflow.index(f"- name: {SEED_CREATE_STEP}\n"),
+ workflow.index(f"- name: {name}\n"),
)
self.assertLess(
- workflow.index(f"- name: {name}"),
- workflow.index("- name: Run Playwright E2E suite"),
+ workflow.index(f"- name: {name}\n"),
+ workflow.index(f"- name: {PLAYWRIGHT_STEP}\n"),
)
def test_seed_dump_excludes_migration_owned_activation_policy(self):
@@ -96,7 +129,7 @@ class E2ESeedCacheContractTests(unittest.TestCase):
)[0]
self.assertIn("--exclude-table='platform.\"PaidUsageActivationPolicy\"'", dump)
- def test_seed_cache_key_uses_pristine_checkout(self):
+ def test_seed_cache_key_is_computed_from_pristine_checkout(self):
workflow = (
Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
).read_text(encoding="utf-8")
@@ -104,35 +137,177 @@ class E2ESeedCacheContractTests(unittest.TestCase):
steps = re.findall(r"^ - name: (.+)$", e2e_job, re.MULTILINE)
self.assertEqual(
steps[:2],
- ["Checkout repository", "Set up tests - Cache E2E test data"],
+ ["Checkout repository", SEED_KEY_STEP],
"seed cache key must be evaluated before generated env/Compose files exist",
)
- def test_seed_cache_covers_transitive_inputs(self):
+ def test_seed_dump_is_not_in_the_actions_cache(self):
+ # The repo's Actions cache sits at its cap and evicted the dump within
+ # minutes: 9 hits in 206 smoke jobs (SECRT-2699).
workflow = (
Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
).read_text(encoding="utf-8")
- key = next(
- line for line in workflow.splitlines() if "key: e2e-test-data-" in line
- )
- patterns = re.findall(r"'([^']+)'", key)
- for path in (
- "autogpt_platform/backend/test/e2e_test_data.py",
- "autogpt_platform/backend/backend/data/graph.py",
- "autogpt_platform/backend/backend/blocks/calculator.py",
- "autogpt_platform/backend/agents/calculator-agent.json",
- "autogpt_platform/backend/schema.prisma",
- "autogpt_platform/backend/poetry.lock",
- "autogpt_platform/autogpt_libs/autogpt_libs/auth/models.py",
- "autogpt_platform/docker-compose.yml",
- "autogpt_platform/.env.default",
- ".github/workflows/platform-fullstack-ci.yml",
- ):
+ for step in workflow.split("\n - name: ")[1:]:
+ if "uses: actions/cache" in step:
+ with self.subTest(step=step.splitlines()[0]):
+ self.assertNotIn("e2e_test_data", step)
+
+ def test_seed_cache_key_covers_only_seed_inputs(self):
+ workflow = (
+ Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
+ ).read_text(encoding="utf-8")
+ key_step = _step(workflow, SEED_KEY_STEP)
+ script = key_step.split("run: |\n", 1)[1]
+ hashed = set(re.findall(r"^\s+(autogpt_platform/\S+?)(?: \\)?$", script, re.M))
+ self.assertEqual(
+ hashed,
+ {
+ "autogpt_platform/backend/test/e2e_test_data.py",
+ "autogpt_platform/backend/agents/calculator-agent.json",
+ "autogpt_platform/backend/schema.prisma",
+ "autogpt_platform/backend/migrations",
+ # Backend helpers the seed calls that write the dumped rows.
+ *(
+ f"autogpt_platform/backend/backend/{module}.py"
+ for module in SEED_WRITERS
+ ),
+ },
+ )
+ # The dump step's own text, not the whole workflow file.
+ self.assertIn(f"/- name: {SEED_CREATE_STEP}$/", script)
+
+ root = Path(__file__).resolve().parents[2]
+ # git ls-files skips a path that is gone, so a rename would quietly
+ # drop it from the key.
+ for path in hashed:
with self.subTest(path=path):
- self.assertTrue(
- any(fnmatch.fnmatchcase(path, pattern) for pattern in patterns),
- f"seed cache key does not cover {path}",
+ self.assertTrue((root / path).exists())
+ outputs = []
+ for _ in range(2):
+ with tempfile.NamedTemporaryFile("r", suffix=".out") as out:
+ subprocess.run(
+ ["bash", "-euo", "pipefail", "-c", script],
+ cwd=root,
+ env={**os.environ, "EMBEDDINGS": "emb", "GITHUB_OUTPUT": out.name},
+ check=True,
)
+ outputs.append(out.read())
+ self.assertEqual(outputs[0], outputs[1], "seed cache key is not deterministic")
+ tag = re.fullmatch(r"tag=(\S+)\n", outputs[0])
+ self.assertIsNotNone(tag, outputs[0])
+ assert tag
+ # A valid OCI tag that names the embeddings mode.
+ self.assertRegex(tag[1], r"^[A-Za-z0-9_][A-Za-z0-9_.-]{0,127}$")
+ self.assertIn("-emb-", tag[1])
+
+ def test_seed_dump_restores_from_ghcr_or_falls_back_to_seeding(self):
+ workflow = (
+ Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
+ ).read_text(encoding="utf-8")
+ self.assertIn("E2E_SEED_IMAGE: ghcr.io/significant-gravitas/", workflow)
+ pull = _step(workflow, SEED_PULL_STEP)
+ restore = _step(workflow, SEED_RESTORE_STEP)
+ create = _step(workflow, SEED_CREATE_STEP)
+ # An unreachable or missing image never fails the job.
+ self.assertIn("continue-on-error: true", pull)
+ self.assertIn("timeout-minutes:", pull)
+ self.assertIn("steps.e2e-seed-pull.outputs.hit == 'true'", restore)
+ # A dump that no longer loads rolls back whole and is seeded fresh.
+ self.assertIn("--single-transaction", restore)
+ self.assertIn("ON_ERROR_STOP=1", restore)
+ self.assertLess(
+ restore.index("--single-transaction"), restore.index("restored=true")
+ )
+ self.assertEqual(
+ re.findall(r"^\s+if: (.+)$", create, re.M),
+ ["matrix.seed && steps.e2e-seed-restore.outputs.restored != 'true'"],
+ )
+ self.assertLess(
+ workflow.index(f"- name: {SEED_KEY_STEP}\n"),
+ workflow.index(
+ "- name: Set up Platform - Log in to the GHCR build cache\n"
+ ),
+ )
+ self.assertLess(
+ workflow.index(
+ "- name: Set up Platform - Log in to the GHCR build cache\n"
+ ),
+ workflow.index(f"- name: {SEED_PULL_STEP}\n"),
+ )
+
+ def test_seed_dump_is_saved_only_where_build_cache_is_written(self):
+ workflow = (
+ Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
+ ).read_text(encoding="utf-8")
+ job_env = workflow.split("\n e2e_test:\n", 1)[1].split("\n steps:\n", 1)[0]
+ self.assertIn("WRITE_BUILD_CACHE: ${{", job_env)
+ save = _step(workflow, SEED_SAVE_STEP)
+ self.assertEqual(
+ re.findall(r"^\s+if: (.+)$", save, re.M),
+ [
+ "matrix.seed && env.WRITE_BUILD_CACHE == 'true' && "
+ "steps.e2e-seed-create.outcome == 'success' && "
+ "steps.e2e-seed-create.outputs.publishable == 'true' && "
+ "steps.e2e-seed-verify.outcome == 'success' && "
+ "steps.e2e-playwright.outcome == 'success' && "
+ "steps.e2e-playwright-report.outcome == 'success'"
+ ],
+ )
+ self.assertIn("continue-on-error: true", save)
+ self.assertIn('docker push "$ref"', save)
+ self.assertIn("id: e2e-seed-create", _step(workflow, SEED_CREATE_STEP))
+ self.assertIn("id: e2e-seed-verify", _step(workflow, SEED_VERIFY_STEP))
+ self.assertIn("id: e2e-playwright", _step(workflow, PLAYWRIGHT_STEP))
+ self.assertIn(
+ "id: e2e-playwright-report", _step(workflow, PLAYWRIGHT_REPORT_STEP)
+ )
+ # The seed swallows graph, store and fixture insert failures, so only
+ # a dump the whole suite passed on is published; a broken one would
+ # otherwise fail every run that restores it.
+ self.assertLess(
+ workflow.index(f"- name: {PLAYWRIGHT_REPORT_STEP}\n"),
+ workflow.index(f"- name: {SEED_SAVE_STEP}\n"),
+ )
+
+ def test_seed_dump_with_incomplete_embeddings_is_not_published(self):
+ # The seed warns and exits 0 when the embedding backfill errors, stalls
+ # or runs out of time; a dump without full coverage must not be reused.
+ workflow = (
+ Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
+ ).read_text(encoding="utf-8")
+ seed = (
+ Path(__file__).resolve().parents[2]
+ / "autogpt_platform/backend/test/e2e_test_data.py"
+ ).read_text(encoding="utf-8")
+ create = _step(workflow, SEED_CREATE_STEP)
+ self.assertIn(EMBEDDINGS_COMPLETE, seed)
+ self.assertIn(f"grep -q '{EMBEDDINGS_COMPLETE}' /tmp/e2e_seed.log", create)
+ self.assertIn("matrix.embeddings", create)
+ self.assertIn('echo "publishable=true" >> "$GITHUB_OUTPUT"', create)
+ self.assertIn(
+ "steps.e2e-seed-create.outputs.publishable == 'true'",
+ _step(workflow, SEED_SAVE_STEP),
+ )
+
+ def test_seed_dump_is_pushed_and_pulled_under_one_name(self):
+ # A one-sided rename would make every pull a miss while CI stays green.
+ workflow = (
+ Path(__file__).resolve().parents[1] / "workflows/platform-fullstack-ci.yml"
+ ).read_text(encoding="utf-8")
+ dumped = re.findall(r"postgres > /tmp/(\S+)$", workflow, re.M)
+ pushed = re.findall(r"tar -C /tmp -c (\S+) \|", _step(workflow, SEED_SAVE_STEP))
+ pulled = re.findall(
+ r'docker cp "\$container:/(\S+)" /tmp/(\S+)$',
+ _step(workflow, SEED_PULL_STEP),
+ re.M,
+ )
+ restored = re.findall(
+ r"cat /tmp/(\S+)$", _step(workflow, SEED_RESTORE_STEP), re.M
+ )
+ self.assertEqual(dumped, ["e2e_test_data.sql"])
+ self.assertEqual(pushed, dumped)
+ self.assertEqual(pulled, [(dumped[0], dumped[0])])
+ self.assertEqual(restored, dumped)
class E2EImageBuildContractTests(unittest.TestCase):
diff --git a/.github/workflows/platform-fullstack-ci.yml b/.github/workflows/platform-fullstack-ci.yml
index e66377d14a..b3cc33b1ee 100644
--- a/.github/workflows/platform-fullstack-ci.yml
+++ b/.github/workflows/platform-fullstack-ci.yml
@@ -221,6 +221,9 @@ jobs:
packages: write
env:
BUILD_CACHE_IMAGE: ghcr.io/significant-gravitas/autogpt-platform-e2e-buildcache
+ E2E_SEED_IMAGE: ghcr.io/significant-gravitas/autogpt-platform-e2e-seed
+ # Both legs build the same images; only smoke writes them.
+ WRITE_BUILD_CACHE: ${{ matrix.suite == 'smoke' && ((github.event_name == 'push' && github.ref == 'refs/heads/dev') || github.event_name == 'merge_group' || (github.event_name == 'workflow_dispatch' && inputs.publish_build_cache)) }}
BUILDKIT_IMAGE: docker.io/moby/buildkit:v0.32.0@sha256:1f8167fcb0eca5b7126353d35299386945cbb8949cc516c592a49f80cfce4fa2
steps:
@@ -230,14 +233,45 @@ jobs:
ref: ${{ github.sha }}
submodules: recursive
- - name: Set up tests - Cache E2E test data
- id: e2e-data-cache
+ # The seed dump is an image in GHCR, not an Actions cache entry.
+ # The key hashes only what changes the dump's content: the seed script
+ # and the graph it loads, the tables it fills, the backend modules the
+ # seed calls to write rows, and the step that dumps them. Other backend
+ # edits keep the key; a dump that no longer loads falls back to seeding.
+ # A dump that still loads is reused even when code outside these paths
+ # changes what the seed writes: if E2E sees old seeded data after such a
+ # change, bump v4 to force a fresh seed.
+ - name: Set up tests - Compute E2E test data cache key
+ id: e2e-seed-key
if: matrix.seed
- uses: actions/cache@caa296126883cff596d87d8935842f9db880ef25 # v5.1.0
- with:
- path: /tmp/e2e_test_data.sql
- # Hash checkout inputs before fresh secrets and resolved Compose exist.
- key: e2e-test-data-v3-${{ matrix.embeddings && 'emb' || 'noemb' }}-${{ hashFiles('autogpt_platform/backend/**', 'autogpt_platform/autogpt_libs/**', 'autogpt_platform/docker-compose*.yml', 'autogpt_platform/.env.default', '.github/workflows/platform-fullstack-ci.yml') }}
+ working-directory: .
+ env:
+ EMBEDDINGS: ${{ matrix.embeddings && 'emb' || 'noemb' }}
+ run: |
+ inputs_hash=$(
+ {
+ git ls-files -s -- \
+ autogpt_platform/backend/test/e2e_test_data.py \
+ autogpt_platform/backend/agents/calculator-agent.json \
+ autogpt_platform/backend/schema.prisma \
+ autogpt_platform/backend/migrations \
+ autogpt_platform/backend/backend/api/features/library/db.py \
+ autogpt_platform/backend/backend/api/features/library/model.py \
+ autogpt_platform/backend/backend/api/features/orgs/db.py \
+ autogpt_platform/backend/backend/api/features/search/embeddings.py \
+ autogpt_platform/backend/backend/api/features/store/db.py \
+ autogpt_platform/backend/backend/data/auth/api_key.py \
+ autogpt_platform/backend/backend/data/credit.py \
+ autogpt_platform/backend/backend/data/graph.py \
+ autogpt_platform/backend/backend/data/org_migration.py \
+ autogpt_platform/backend/backend/data/profile.py \
+ autogpt_platform/backend/backend/data/user.py \
+ autogpt_platform/backend/backend/util/json.py
+ sed -n '/- name: Set up tests - Create E2E test data$/,/^ - name:/p' \
+ .github/workflows/platform-fullstack-ci.yml
+ } | sha256sum | cut -c1-40
+ )
+ echo "tag=v4-${EMBEDDINGS}-${inputs_hash}" >> "$GITHUB_OUTPUT"
- name: Set up Platform - Pull BuildKit image
id: buildkit-image
@@ -285,13 +319,30 @@ jobs:
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
+ # A miss, a pull error or no access (fork PRs) just means seeding below.
+ - name: Set up tests - Pull cached E2E test data from GHCR
+ id: e2e-seed-pull
+ if: matrix.seed
+ continue-on-error: true
+ timeout-minutes: 3
+ working-directory: /tmp
+ run: |
+ ref="$E2E_SEED_IMAGE:${{ steps.e2e-seed-key.outputs.tag }}"
+ if ! docker pull --quiet "$ref"; then
+ echo "No cached E2E test data at $ref; seeding instead"
+ exit 0
+ fi
+ container=$(docker create "$ref" none)
+ docker cp "$container:/e2e_test_data.sql" /tmp/e2e_test_data.sql
+ docker rm "$container" >/dev/null
+ docker rmi "$ref" >/dev/null
+ echo "hit=true" >> "$GITHUB_OUTPUT"
+
- name: Set up Platform - Prepare Docker build
working-directory: autogpt_platform
env:
NEXT_PUBLIC_PW_TEST: true
NEXT_PUBLIC_SOURCEMAPS: true
- # Both legs build the same images; only smoke writes them.
- WRITE_BUILD_CACHE: ${{ matrix.suite == 'smoke' && ((github.event_name == 'push' && github.ref == 'refs/heads/dev') || github.event_name == 'merge_group' || (github.event_name == 'workflow_dispatch' && inputs.publish_build_cache)) }}
run: |
pip install pyyaml
@@ -451,18 +502,25 @@ jobs:
NEXT_PUBLIC_PW_TEST: true
- name: Set up tests - Load cached E2E test data
- if: steps.e2e-data-cache.outputs.cache-hit == 'true'
+ id: e2e-seed-restore
+ if: steps.e2e-seed-pull.outputs.hit == 'true'
run: |
echo "✅ Found cached E2E test data, restoring..."
+ # One transaction: a dump that no longer fits the schema leaves
+ # nothing behind, and the seed step below runs instead.
{
echo "SET session_replication_role = 'replica';"
cat /tmp/e2e_test_data.sql
echo "SET session_replication_role = 'origin';"
- } | docker compose -f ../docker-compose.resolved.yml exec -T db psql -X -v ON_ERROR_STOP=1 -U postgres -d postgres -b
+ } | docker compose -f ../docker-compose.resolved.yml exec -T db psql -X -v ON_ERROR_STOP=1 --single-transaction -U postgres -d postgres -b || {
+ echo "::warning title=e2e-seed-cache-stale::Cached E2E test data did not load; seeding instead"
+ exit 0
+ }
# Refresh materialized views after restore
docker compose -f ../docker-compose.resolved.yml exec -T db \
psql -X -v ON_ERROR_STOP=1 -U postgres -d postgres -b -c "SET search_path TO platform; SELECT refresh_store_materialized_views();"
+ echo "restored=true" >> "$GITHUB_OUTPUT"
echo "✅ E2E test data restored from cache"
- name: Set up Platform - Start (all other services)
@@ -488,11 +546,14 @@ jobs:
NEXT_PUBLIC_PW_TEST: true
- name: Set up tests - Create E2E test data
- if: matrix.seed && steps.e2e-data-cache.outputs.cache-hit != 'true'
+ id: e2e-seed-create
+ if: matrix.seed && steps.e2e-seed-restore.outputs.restored != 'true'
+ env:
+ EMBEDDINGS: ${{ matrix.embeddings }}
run: |
echo "Creating E2E test data..."
docker cp ../backend/test/e2e_test_data.py $(docker compose -f ../docker-compose.resolved.yml ps -q rest_server):/tmp/e2e_test_data.py
- docker compose -f ../docker-compose.resolved.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python /tmp/e2e_test_data.py" || {
+ docker compose -f ../docker-compose.resolved.yml exec -T rest_server sh -c "cd /app/autogpt_platform && python /tmp/e2e_test_data.py" | tee /tmp/e2e_seed.log || {
echo "❌ E2E test data creation failed!"
docker compose -f ../docker-compose.resolved.yml logs --tail=50 rest_server
exit 1
@@ -512,7 +573,16 @@ jobs:
echo "✅ Database dump created for caching ($(wc -l < /tmp/e2e_test_data.sql) lines)"
+ # The seed only warns when the embedding backfill errors, stalls or
+ # times out. Such a dump serves this run but is not published.
+ if [[ "$EMBEDDINGS" != "true" ]] || grep -q 'Embeddings complete:' /tmp/e2e_seed.log; then
+ echo "publishable=true" >> "$GITHUB_OUTPUT"
+ else
+ echo "::warning title=e2e-seed-not-published::Embedding coverage is incomplete; this dump will not be pushed to GHCR"
+ fi
+
- name: Set up tests - Verify seeded credentials with fresh encryption key
+ id: e2e-seed-verify
if: matrix.seed
run: |
docker cp ../backend/test/e2e_test_data.py $(docker compose -f ../docker-compose.resolved.yml ps -q rest_server):/tmp/e2e_test_data.py
@@ -538,6 +608,7 @@ jobs:
docker cp "$FRONTEND_CONTAINER":/app/.next/static .next-static-coverage
- name: Run Playwright E2E suite
+ id: e2e-playwright
run: pnpm exec playwright test --config ${{ matrix.config }} ${{ matrix.playwright_args }} ${{ matrix.suite == 'journeys' && format('--repeat-each={0}', inputs.journeys_repeat_each || 1) || '' }} --retries=0 --trace=retain-on-failure
env:
PLAYWRIGHT_JSON_OUTPUT_FILE: test-results/results.json
@@ -571,6 +642,7 @@ jobs:
du -sh /tmp/next-build-cache
- name: Validate Playwright JSON report
+ id: e2e-playwright-report
if: ${{ always() }}
# Each leg's floor is pinned in the matrix; raise it when adding tests.
run: >-
@@ -580,6 +652,21 @@ jobs:
${{ matrix.known_failures && '--allow-known-failures' || '' }}
test-results/results.json
+ # The seed logs and skips some failed inserts (graphs, store, fixtures),
+ # so only a dump the whole suite passed on is published. Pull requests
+ # only read it.
+ - name: Push E2E test data to GHCR
+ if: matrix.seed && env.WRITE_BUILD_CACHE == 'true' && steps.e2e-seed-create.outcome == 'success' && steps.e2e-seed-create.outputs.publishable == 'true' && steps.e2e-seed-verify.outcome == 'success' && steps.e2e-playwright.outcome == 'success' && steps.e2e-playwright-report.outcome == 'success'
+ continue-on-error: true
+ timeout-minutes: 5
+ working-directory: /tmp
+ run: |
+ ref="$E2E_SEED_IMAGE:${{ steps.e2e-seed-key.outputs.tag }}"
+ tar -C /tmp -c e2e_test_data.sql | docker import \
+ --change "LABEL org.opencontainers.image.source=https://github.com/${{ github.repository }}" \
+ - "$ref"
+ docker push "$ref"
+
- name: Validate coverage report
id: validate-e2e-coverage
if: ${{ always() }}