kempo-media 0.3.2 → 0.3.3

package/.github/workflows/publish.yml

@@ -26,6 +26,25 @@ jobs:
     permissions:
       contents: write
       id-token: write
+    # The database-backed suites skip themselves when no database is reachable, which reads as a pass.
+    # Publishing used to run without one, so a release could go out while the test workflow was red.
+    # This is the same service and schema the test workflow uses, so the two gates agree.
+    services:
+      postgres:
+        image: postgres:16-alpine
+        env:
+          POSTGRES_USER: kempo
+          POSTGRES_PASSWORD: kempo
+          POSTGRES_DB: kempo_media_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    env:
+      DATABASE_URL: postgresql://kempo:kempo@localhost:5432/kempo_media_test
     steps:
       - uses: actions/checkout@v4
         with:
@@ -49,9 +68,15 @@ jobs:
       - name: Install the host for the test gate
         run: npm install --no-save kempo@latest kempo-files@latest kempo-thumbs@latest kempo-ui@latest kempo-server@latest
 
-      - name: Run Unit Tests
+      - name: Apply database schema
+        run: npx drizzle-kit push --force
+
+      - name: Run unit tests
         run: npm test
 
+      - name: Run integration tests
+        run: npm run test:integration
+
       - name: Set version type
         id: version
         run: |

package/.github/workflows/test.yml

@@ -11,9 +11,30 @@ on:
       - master
 
 jobs:
-  # kempo/kempo-ui/kempo-server resolve from the registry, which is what a site installing this
-  # extension gets. Peer dependencies are installed automatically by npm ci.
-  published:
+  # Unit tier: an in-memory Postgres (PGlite), so there is no service to start and a database
+  # suite cannot skip for want of one.
+  unit:
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22.x'
+
+      - run: npm ci
+
+      # kempo, kempo-files, kempo-thumbs, kempo-ui and kempo-server are peer dependencies, which npm ci does not install.
+      - name: Install the host for the test gate
+        run: npm install --no-save kempo@latest kempo-files@latest kempo-thumbs@latest kempo-ui@latest kempo-server@latest
+
+      - name: Run unit tests
+        run: npm test
+
+
+  # Integration tier: the whole suite on a real Postgres. An unreachable database fails it.
+  integration:
     if: "!contains(github.event.head_commit.message, '[skip ci]')"
     runs-on: ubuntu-latest
     services:
@@ -50,8 +71,9 @@ jobs:
       - name: Apply database schema
         run: npx drizzle-kit push --force
 
-      - name: Run Unit Tests
-        run: npm test
+      - name: Run integration tests
+        run: npm run test:integration
+
 
   # Same suite against the sibling checkout of the host. This extension resolves imports out of
   # kempo, so it breaks whenever the host moves something it reaches into — this job is what
@@ -129,6 +151,10 @@ jobs:
         run: npx drizzle-kit push --force
         working-directory: kempo-media
 
-      - name: Run Unit Tests
+      - name: Run unit tests
         run: npm test
         working-directory: kempo-media
+
+      - name: Run integration tests
+        run: npm run test:integration
+        working-directory: kempo-media

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kempo-media",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Media library extension for kempo — upload and manage images, video, audio, 3D models, and archives, stored in kempo-files with thumbnails from kempo-thumbs",
   "license": "MIT",
   "author": "Dustin Poissant",
@@ -8,7 +8,8 @@
   "main": "sdk.js",
   "scripts": {
     "build": "node scripts/build.js",
-    "test": "kempo-test -l minimal",
+    "test": "node scripts/run-tests.js unit kempo-test -l minimal",
+    "test:integration": "node scripts/run-tests.js integration kempo-test -l minimal",
     "link:local": "npm install ../kempo ../kempo-files ../kempo-thumbs ../kempo-server ../kempo-ui --no-save --no-legacy-peer-deps --force"
   },
   "kempo": {
@@ -33,6 +34,7 @@
     "kempo-ui": ">=0.4.43"
   },
   "devDependencies": {
+    "@electric-sql/pglite": "^0.5.9",
     "drizzle-kit": "^0.31.10",
     "kempo-testing-framework": "^1.4.11",
     "postgres": "^3.4.9"

package/scripts/run-tests.js

@@ -0,0 +1,47 @@
+import { spawnSync } from 'child_process';
+import { pathToFileURL } from 'url';
+import path from 'path';
+
+/*
+  The two test tiers, then the command to run in each.
+
+    unit         `KEMPO_DB=pglite`: kempo's database module gives an in-process, in-memory Postgres
+                 (PGlite) holding the tables in drizzle.config.js, so nothing external is needed and a
+                 database suite can never skip for want of one.
+    integration  a real Postgres at DATABASE_URL, for the suites that boot a second server process.
+                 Here an unreachable database fails the run instead of skipping, so it cannot look
+                 green without having run.
+
+  `npm test` is the unit tier. `npm run test:integration` runs the whole suite on a real database. CI
+  runs both.
+
+  Usage: node scripts/run-tests.js <unit|integration> <command> [arguments]
+*/
+
+const [tier, command, ...args] = process.argv.slice(2);
+
+if(!['unit', 'integration'].includes(tier) || !command){
+  console.error('Usage: node scripts/run-tests.js <unit|integration> <command> [arguments]');
+  process.exit(2);
+}
+
+const env = { ...process.env };
+
+if(tier === 'unit'){
+  env.KEMPO_DB = 'pglite';
+  delete env.KEMPO_TEST_TIER;
+  // Create the database before any test file can install globals that confuse it. See the preload.
+  const preload = pathToFileURL(path.resolve(import.meta.dirname, '..', 'tests', 'helpers', 'preload.js')).href;
+  env.NODE_OPTIONS = `${env.NODE_OPTIONS || ''} --import=${preload}`.trim();
+} else {
+  delete env.KEMPO_DB;
+  env.KEMPO_TEST_TIER = 'integration';
+  if(!env.DATABASE_URL){
+    console.error('The integration tier needs DATABASE_URL pointing at a throwaway Postgres (named *_test) with the schema applied (npx drizzle-kit push).');
+    process.exit(2);
+  }
+}
+
+const result = spawnSync(command, args, { stdio: 'inherit', env, shell: true });
+
+process.exit(result.status ?? 1);

package/tests/helpers/db.js

@@ -0,0 +1,19 @@
+/*
+  Shared by the database-backed suites. See scripts/run-tests.js for the tiers.
+*/
+
+export const unitTier = process.env.KEMPO_DB === 'pglite';
+export const integrationTier = process.env.KEMPO_TEST_TIER === 'integration';
+
+/*
+  The suite for a file that belongs to the integration tier, reported as such in the unit tier. It is
+  explicit rather than a silent skip, and `npm run test:integration` is where it runs.
+*/
+export const integrationOnly = name => ({
+  [`${name} (integration tier)`]: async ({ pass }) => pass('runs in `npm run test:integration`: it needs a real Postgres or a second server process'),
+});
+
+/*
+  Seeds kempo's system groups, permissions and settings in-process. Needs kempo >= 4.5.5.
+*/
+export const seedDatabase = async () => (await import('kempo/server/utils/setup/seedDatabase.js')).default({ log: () => {} });

package/tests/helpers/preload.js

@@ -0,0 +1,10 @@
+/*
+  Loaded with `--import` by scripts/run-tests.js in the unit tier, before any test file.
+
+  The in-memory database is created on first import of kempo's database module. Creating it here, in a
+  clean process, keeps the run from depending on which suite imports it first or on globals a test
+  file has installed by then.
+*/
+if(process.env.KEMPO_DB === 'pglite'){
+  await import('kempo/server/db/index.js');
+}

package/tests/media-api-contract.node-test.js

@@ -1,3 +1,4 @@
+import { unitTier, integrationOnly } from './helpers/db.js';
 import { spawn, execFileSync } from 'child_process';
 import { writeFile, mkdir, rm, readFile, stat } from 'fs/promises';
 import path from 'path';
@@ -465,6 +466,8 @@ const buildTests = () => {
   };
 };
 
-export default databaseReachable
+export default unitTier
+  ? integrationOnly('media API contract')
+  : databaseReachable
   ? buildTests()
   : skipped('no reachable database — see the "Local development" section of the README (docker compose up -d, then npx drizzle-kit push)');

package/tests/media-data-layer.node-test.js

@@ -79,6 +79,13 @@ const purge = async () => {
   }
 };
 
+/*
+  kempo-files' media folder also lives on disk, and the disk outlives a database. A fresh in-memory
+  database has no row for a folder an earlier run left behind, so the first upload would be refused
+  ("already exists on disk"). This suite owns that folder, so start from none.
+*/
+await rm(path.join(process.cwd(), 'files', 'media'), { recursive: true, force: true }).catch(() => {});
+
 const buildTests = () => ({
   'createMediaAsset records every column and stamps timestamps': async ({ pass, fail }) => {
     const [error, row] = await create({ altText: 'A test image' });

package/tests/media-migration.node-test.js

@@ -78,6 +78,12 @@ const cleanup = async () => {
   for(const id of Object.values(IDS)) await deleteFile({ id }).catch(() => {});
   await db.delete(kempoMediaAsset).where(inArray(kempoMediaAsset.id, Object.values(IDS))).catch(() => {});
   await db.delete(settingTable).where(eq(settingTable.name, 'kempo-media:thumbnail_max_dimension')).catch(() => {});
+  /*
+    kempo-files' folders also live on disk, and the disk outlives a database. A run on a fresh in-memory
+    database has no row for the media folder an earlier run left behind, and the migration then refuses
+    to create it ("already exists on disk"). This suite owns that folder, so reset it.
+  */
+  await rm(path.join(process.cwd(), 'files', 'media'), { recursive: true, force: true }).catch(() => {});
   await removeExtensions();
   await db.execute(sql.raw(`ALTER TABLE "kempoMediaAsset" DROP COLUMN IF EXISTS "filename", DROP COLUMN IF EXISTS "path", DROP COLUMN IF EXISTS "thumbnailPath"`)).catch(() => {});
   if(state.site) await rm(state.site, { recursive: true, force: true }).catch(() => {});