diff --git a/.dockerignore b/.dockerignore index 43870ca..1ab01c3 100644 --- a/.dockerignore +++ b/.dockerignore @@ -10,3 +10,5 @@ docker-compose*.yml Dockerfile README.md *.tsbuildinfo +tests +vitest.config.mts diff --git a/README.md b/README.md index 1644037..1ea0863 100644 --- a/README.md +++ b/README.md @@ -196,6 +196,29 @@ Namnen viktas efter hur vanliga de var, så en man född 1960 blir oftare Anders - Från en posts sida kan du gå direkt till *Placera på karta*. - Kartplattor och adressökning hämtas som standard från OpenStreetMaps publika servrar, som är tänkta för lätt användning. För tyngre bruk, sätt `MAP_TILE_URL` och `MAP_GEOCODER_URL` till egen eller betald tjänst. Adressökningar skickas då från webbläsaren till den tjänsten. +## Tester + +Testerna körs med Vitest (`npm test`). Det finns cirka 170 tester: + +- **Enhetstester utan databas** (`tests/unit`): mallar och deras validering, ID-prefix, hastighetsbegränsning, säkerhetsrubriker, namngenerering, historikens jämförelser, bildbehandling (storlek, EXIF-rotation, borttagen metadata) och läsning och kontroll av importfiler (inklusive skydd mot för stora filer). +- **Databastester** (`tests/db`): löpande ID (även vid samtidiga anrop), export och import fram och tillbaka med bilder och kopplingar, papperskorg (poster och böcker), historikens gräns, fältvärden och kopplingskontroller, säkerhetskopiering (rensning, schema, att zip-filerna går att importera), lagringskvot, administratör och sök. + +Databastesterna behöver en PostgreSQL-databas och använder alltid en **egen testdatabas** vars namn slutar på `_test`. De tömmer den mellan testerna och vägrar köra mot en databas med något annat namn, så din riktiga data berörs aldrig. Databasen skapas och migreras automatiskt första gången. + +Med Docker (utvecklingsmiljön) räcker det att köra: + +```bash +docker compose -f docker-compose.dev.yml exec app npm test +``` + +Testdatabasen blir då `bookmanager_test` i samma databasserver. Utan Docker, peka på en databasserver (användaren behöver få skapa databaser): + +```bash +TEST_DATABASE_URL=postgresql://användare:lösenord@localhost:5432/bookmanager_test npm test +``` + +Saknas databas körs bara enhetstesterna och databastesterna hoppas över. Uppladdade filer och säkerhetskopior från testerna hamnar i en tillfällig mapp som städas bort. `npm run typecheck` kontrollerar även testfilerna. + ## Struktur ``` diff --git a/TODO.md b/TODO.md index e669430..f481f2b 100644 --- a/TODO.md +++ b/TODO.md @@ -68,6 +68,46 @@ jobs: **Valfritt:** automatisk uppdatering av prod (Watchtower, eller ett SSH-steg som bara körs på versionstaggar). Rekommendation: vänta tills flödet känns tryggt. +## Köra testerna automatiskt i Gitea Actions + +Kör typkontroll och tester vid varje push och pull request, innan imagen byggs. Databastesterna behöver en PostgreSQL-tjänst; databasen måste heta något som slutar på `_test` (testerna lägger själva på `_test` om det saknas). + +**Utkast till `.gitea/workflows/test.yml`** + +```yaml +name: Tester + +on: + push: + branches: [main] + pull_request: + +jobs: + test: + runs-on: ubuntu-latest + services: + postgres: + image: postgres:16 + env: + POSTGRES_USER: test + POSTGRES_PASSWORD: test + POSTGRES_DB: bookmanager + env: + DATABASE_URL: postgresql://test:test@postgres:5432/bookmanager + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-node@v4 + with: + node-version: 22 + cache: npm + - run: npm ci + - run: npx prisma generate + - run: npm run typecheck + - run: npm test +``` + +Samma `act_runner` som för publiceringen räcker. Tjänstecontainern nås som `postgres` när jobbet körs i en container; om runnern kör direkt på värden byts adressen mot `localhost` och en publicerad port. Låt publiceringsflödet vänta på testerna (`needs: test`) när båda finns på plats. + ## Verifiera - Ladda upp en stor kartbild (10–15 MB). Gränsen för förfrågningar via inloggningskontrollen höjdes till 300 MB i samband med import och export, men en stor kartbild är inte testad. diff --git a/package-lock.json b/package-lock.json index 10625db..ce9458c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -26,7 +26,8 @@ "@types/node": "^22.10.0", "@types/react": "^19.1.0", "@types/react-dom": "^19.1.0", - "typescript": "^5.9.3" + "typescript": "^5.9.3", + "vitest": "^5.0.5" } }, "node_modules/@auth/core": { @@ -590,6 +591,34 @@ "url": "https://opencollective.com/libvips" } }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, "node_modules/@next/env": { "version": "15.5.28", "resolved": "https://registry.npmjs.org/@next/env/-/env-15.5.28.tgz", @@ -736,6 +765,17 @@ "node": ">= 10" } }, + "node_modules/@oxc-project/types": { + "version": "0.156.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.156.0.tgz", + "integrity": "sha512-1Duyg48TdJNdyhEB8Xn1L36bT9Pv6GUtlKjHxOys8xkaF/rQq3XJE+bAurSK/AgIz5mGFsb77cn9Pb20+WCScw==", + "dev": true, + "license": "MIT", + "peer": true, + "funding": { + "url": "https://github.com/sponsors/oxc-project" + } + }, "node_modules/@panva/hkdf": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/@panva/hkdf/-/hkdf-1.2.1.tgz", @@ -834,6 +874,302 @@ "@prisma/debug": "6.19.3" } }, + "node_modules/@rolldown/binding-android-arm-eabi": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm-eabi/-/binding-android-arm-eabi-1.2.16.tgz", + "integrity": "sha512-ia3DwAs0OsMGS7+IConptSiyk9pEXkOx/AbJ2n/lAGxH3QkWQus1t8d7gnAT38FCU2sQu8lUbeR6AiZFv4JxaA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-android-arm64": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.16.tgz", + "integrity": "sha512-kx5wBiMB6E7TEvpl2B9gjLU004BkvEm2Dr941BFjx/SontPwSzNuQUIoVKxHHoSjpFIfHMmcguyLOtyn0hObRg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-arm64": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.16.tgz", + "integrity": "sha512-qslZrXnKJU4cUpjoAmtAo/KQM9e2IRMlmpig6Zpwj+8KWxW8v+nkAf9216Bsek9lOC1jvg2yCjygCFo2f83msQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-x64": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.16.tgz", + "integrity": "sha512-FdF+y48ND13eAyM2mQn+85kvAqNlvRWROy2rhgA463X/0Gv4vGtazZtfaF1mRBLscYvtOlh4QnLjOWiFzX69OQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-freebsd-x64": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.16.tgz", + "integrity": "sha512-ddjqFM5e95AgLbUPtKIS7V1KTVlA0RUgCVr5mn+/IEhsdy3pr+Vuj/HZ7nlMN2FyxIwUktOH1LEPIQXO1v9y1Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm-gnueabihf": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.16.tgz", + "integrity": "sha512-tHdKWbFkFBI687iim3LIyIvyL7j66VvQYkDPss5Stn/qyE2tWkR1YD0dXmXPFKKqT/o5ZEJVsaRsWS2meQwGOA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-gnu": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.16.tgz", + "integrity": "sha512-FJiLGAblPBMlBEdbOqw6kW6QcXDWAf/oJu7gYs9ZJZwmg+K+/zjFLxPTIY9izJUzxzc24FHvmseyA0IvJSl17w==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-musl": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.16.tgz", + "integrity": "sha512-hrJpblMsrQ58U9veWpbXzkhV5zStunds6HWLprqq1qauvgBr1E6P+24kLj6lSLI9vjRn/RYpjprhkHQPKGWpNg==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-ppc64-gnu": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.16.tgz", + "integrity": "sha512-qJd/dC6j6CwLG9/s/RP2nb1RZ0GIgj7Ioj7x/SYa3RzjVrlzrmH0fhIOpfvqQDeIsdP0loi+kHaMhJzY1PBIaA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-s390x-gnu": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.16.tgz", + "integrity": "sha512-Vx7Xg5uUJuNcujJjI70OICaH0EYj80BtOLZTSN7uOYg8QOLlyKnaG0IW7Fn/J0IpJsaKzmDKMhOQv1JBM9m9vg==", + "cpu": [ + "s390x" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.16.tgz", + "integrity": "sha512-TNKhgE3uJTsTzatUSSYt0Kgo+Oa2uSlSjz4r1aEIea7HX6ULBym4fAlYUhG1i6pjNf2njfCUAfKwr6C3E9Xg1w==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-musl": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.16.tgz", + "integrity": "sha512-7chXdpjXZ8qG0+mIxECN3cT9kvhZ3/oZhMX6Pp876P7CDrIy8nJswva6Mq357JR7eYXfuskwZxMeV1SzoZdHrA==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-openharmony-arm64": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.16.tgz", + "integrity": "sha512-Kwjt+7uNTJK5/MDkGWGVO2KQPnj8yAV75dMpfwyHZrJSXWHrniOB0aUEWlVYf3H1hOqFLIStLdM5QXq6bnKmOQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-arm64-msvc": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.16.tgz", + "integrity": "sha512-/LH6WfjDRXXJz/p5xl4TmU+jpcnwcxbKEQBW/GZE0JHfN0lGIyTtsUEGaQ/q/GikkGJ2yLKe6pwm7AnEWO8pdw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-x64-msvc": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.16.tgz", + "integrity": "sha512-1lv1KvX0Z871zfk7vw+dnXMMnHNyDwMzWG8Kv3HxDXMOhzCX4SHc7HK319fInP0i+0p9D8brkfzL7pJOaGl+tw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "peer": true, + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz", + "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==", + "dev": true, + "license": "MIT", + "peer": true + }, "node_modules/@standard-schema/spec": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", @@ -899,6 +1235,31 @@ "react": ">= 16" } }, + "node_modules/@types/chai": { + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" + } + }, + "node_modules/@types/deep-eql": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", + "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/estree": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.10.tgz", + "integrity": "sha512-lTyOMnOcmRBzdCv6/4zUZCrEhV0xrqQiUZBZtVcbmLHBXKLnN8q89v/wKRF/Q0HbwVsqbIG3o5HDoFl9sduM+g==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/geojson": { "version": "7946.0.16", "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz", @@ -946,6 +1307,54 @@ "@types/react": "^19.3.0" } }, + "node_modules/@vitest/mocker": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-5.0.5.tgz", + "integrity": "sha512-xLL3lkDegJZw+MGoGaCCsFayDZthGgpAtr3Vziyfc4p7xH89K7KRPcRBBh/kEYm0Aqkt5DtTmkYpBtRV/FrHZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "0.3.31", + "@vitest/spy": "5.0.5", + "estree-walker": "^3.0.3", + "magic-string": "^1.4.3" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9 || ^3.0.0", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/@vitest/spy": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-5.0.5.tgz", + "integrity": "sha512-lwJRExuH417257Q5wv9QYugN9IMJkoxcrKrYxGPQkBzl7wlNpTUxD/5yNX4ESKVUIShKPgkGchYPFMWOOk0wzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, "node_modules/c12": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/c12/-/c12-3.1.0.tgz", @@ -994,6 +1403,16 @@ ], "license": "CC-BY-4.0" }, + "node_modules/chai": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/chai/-/chai-6.3.0.tgz", + "integrity": "sha512-XWAtwJ6OHO+tj0EKCs0Y2UamnyOxseZWltU4x2U2wh8g4AigdjwvtUjvLP2tqkA/avxHEtzxNaqGq/YGNwckKg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, "node_modules/chokidar": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz", @@ -1107,6 +1526,33 @@ "node": ">=14" } }, + "node_modules/es-module-lexer": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz", + "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==", + "dev": true, + "license": "MIT" + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/expect-type": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz", + "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, "node_modules/exsolve": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/exsolve/-/exsolve-1.1.3.tgz", @@ -1135,12 +1581,46 @@ "node": ">=8.0.0" } }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, "node_modules/fflate": { "version": "0.8.3", "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz", "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==", "license": "MIT" }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, "node_modules/giget": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/giget/-/giget-2.0.0.tgz", @@ -1182,6 +1662,301 @@ "integrity": "sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==", "license": "BSD-2-Clause" }, + "node_modules/lightningcss": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz", + "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==", + "dev": true, + "license": "MPL-2.0", + "peer": true, + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.33.0", + "lightningcss-darwin-arm64": "1.33.0", + "lightningcss-darwin-x64": "1.33.0", + "lightningcss-freebsd-x64": "1.33.0", + "lightningcss-linux-arm-gnueabihf": "1.33.0", + "lightningcss-linux-arm64-gnu": "1.33.0", + "lightningcss-linux-arm64-musl": "1.33.0", + "lightningcss-linux-x64-gnu": "1.33.0", + "lightningcss-linux-x64-musl": "1.33.0", + "lightningcss-win32-arm64-msvc": "1.33.0", + "lightningcss-win32-x64-msvc": "1.33.0" + } + }, + "node_modules/lightningcss-android-arm64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.33.0.tgz", + "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "android" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-arm64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.33.0.tgz", + "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-x64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.33.0.tgz", + "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-freebsd-x64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.33.0.tgz", + "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm-gnueabihf": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.33.0.tgz", + "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-gnu": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.33.0.tgz", + "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-musl": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.33.0.tgz", + "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz", + "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-musl": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.33.0.tgz", + "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "musl" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-arm64-msvc": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.33.0.tgz", + "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-x64-msvc": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.33.0.tgz", + "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "peer": true, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/magic-string": { + "version": "1.4.5", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-1.4.5.tgz", + "integrity": "sha512-oLLC2+YvQUfAa+vxoufE/yc1icb87M9iXIRqAoR/2EhE/8cb3SF/+Gi0c2By1B+5Vz2e2vQtUvHiu1+63Znh+w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.6.0" + } + }, "node_modules/nanoid": { "version": "3.3.20", "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.20.tgz", @@ -1317,6 +2092,20 @@ "url": "https://github.com/sponsors/panva" } }, + "node_modules/obug": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/obug/-/obug-3.0.0.tgz", + "integrity": "sha512-5vvB5+W7ePv+p3uqxi+RcW1XAzLW0/hxt3/4X4Lc4qHudzOhmBiBwOY6DRob4WnanAEGvNcLjF+KNOufrUoEQw==", + "dev": true, + "funding": [ + "https://github.com/sponsors/sxzz", + "https://opencollective.com/debug" + ], + "license": "MIT", + "engines": { + "node": ">=12.20.0" + } + }, "node_modules/ohash": { "version": "2.0.12", "resolved": "https://registry.npmjs.org/ohash/-/ohash-2.0.12.tgz", @@ -1341,6 +2130,19 @@ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", "license": "ISC" }, + "node_modules/picomatch": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz", + "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/pkg-types": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.4.0.tgz", @@ -1490,6 +2292,41 @@ "url": "https://paulmillr.com/funding/" } }, + "node_modules/rolldown": { + "version": "1.2.16", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.16.tgz", + "integrity": "sha512-bWvlMpFKiTfDKfnK7FC2MPgPeWCf/Kpwsq49ApdW+FQaBZb6O6dZ4MAPbPUjp7hYQrw/RobqCzn64BRrQecGHw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@oxc-project/types": "=0.156.0", + "@rolldown/pluginutils": "^1.0.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm-eabi": "1.2.16", + "@rolldown/binding-android-arm64": "1.2.16", + "@rolldown/binding-darwin-arm64": "1.2.16", + "@rolldown/binding-darwin-x64": "1.2.16", + "@rolldown/binding-freebsd-x64": "1.2.16", + "@rolldown/binding-linux-arm-gnueabihf": "1.2.16", + "@rolldown/binding-linux-arm64-gnu": "1.2.16", + "@rolldown/binding-linux-arm64-musl": "1.2.16", + "@rolldown/binding-linux-ppc64-gnu": "1.2.16", + "@rolldown/binding-linux-s390x-gnu": "1.2.16", + "@rolldown/binding-linux-x64-gnu": "1.2.16", + "@rolldown/binding-linux-x64-musl": "1.2.16", + "@rolldown/binding-openharmony-arm64": "1.2.16", + "@rolldown/binding-win32-arm64-msvc": "1.2.16", + "@rolldown/binding-win32-x64-msvc": "1.2.16" + } + }, "node_modules/scheduler": { "version": "0.28.0", "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.28.0.tgz", @@ -1561,6 +2398,13 @@ "node": ">=0.10.0" } }, + "node_modules/std-env": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.3.0.tgz", + "integrity": "sha512-OtU/EgQ1kIm5KwqQpBC6ZEMXrZRui11w8zgfTWp8cdO9B8OaPsbA8bTHO2P+HNo1VlUTGMVBwPhydu6poeXiag==", + "dev": true, + "license": "MIT" + }, "node_modules/styled-jsx": { "version": "5.1.6", "resolved": "https://registry.npmjs.org/styled-jsx/-/styled-jsx-5.1.6.tgz", @@ -1584,6 +2428,16 @@ } } }, + "node_modules/tinybench": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-6.2.3.tgz", + "integrity": "sha512-Al01C2JIBnO2CXCAPbpAl6sUiOZHeThGtHYNTa51JRw9PyWOCdr+9Ong05R4qg/Sk3+H645E8ov1h2c58ityNw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.0.0" + } + }, "node_modules/tinyexec": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.3.1.tgz", @@ -1593,6 +2447,23 @@ "node": ">=18" } }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, "node_modules/tslib": { "version": "2.8.1", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", @@ -1619,6 +2490,211 @@ "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", "dev": true, "license": "MIT" + }, + "node_modules/vite": { + "version": "8.3.5", + "resolved": "https://registry.npmjs.org/vite/-/vite-8.3.5.tgz", + "integrity": "sha512-z1YpjieJ9g0ebTmQpLBv/oq9E3F9EIlOe+7LahW8SrE3LTiG3udBRUXQOlYXP9b+IC2q2phHeVxj9xGlw34OEQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "lightningcss": "^1.33.0", + "picomatch": "^4.0.7", + "postcss": "^8.5.30", + "rolldown": "~1.2.14", + "tinyglobby": "^0.2.17" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "@vitejs/devtools": "^0.7.1 || ^0.8.0", + "esbuild": "^0.27.0 || ^0.28.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "@vitejs/devtools": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite/node_modules/postcss": { + "version": "8.5.32", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.32.tgz", + "integrity": "sha512-LJlKCCAUFKOuZxipUdYw1NzIITEsPcgyOG9LkvRJvuKj/bRzbuRY0ARXvL0pWGpsZvn8jku+LMep2eU0seHp8g==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "peer": true, + "dependencies": { + "nanoid": "^3.3.20", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.2" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/vitest": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-5.0.5.tgz", + "integrity": "sha512-cPODOMF8YnkiiYtDdHo6n4wWmBrOBBbOIYH2d33M4l3CdNn72h+qMmO6uXffUN6A5AZFXNND/d+krS9mgkXRfg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/chai": "^5.2.2", + "@vitest/mocker": "5.0.5", + "chai": "^6.3.0", + "es-module-lexer": "^2.3.2", + "expect-type": "^1.4.0", + "magic-string": "^1.4.3", + "obug": "^3.0.0", + "picomatch": "^4.0.7", + "std-env": "^4.3.0", + "tinybench": "^6.2.2", + "tinyexec": "^1.3.1", + "tinyglobby": "^0.2.17", + "why-is-node-running": "3.2.1" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^22.12.0 || ^24.0.0 || >=26.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@opentelemetry/api": "^1.9.0", + "@types/node": "^22.0.0 || >=24.0.0", + "@vitest/browser-playwright": "5.0.5", + "@vitest/browser-preview": "5.0.5", + "@vitest/browser-webdriverio": "^5.0.0-beta.5 || >=5.0.0", + "@vitest/coverage-istanbul": "5.0.5", + "@vitest/coverage-v8": "5.0.5", + "@vitest/ui": "5.0.5", + "happy-dom": "*", + "jsdom": "*", + "vite": "^6.4.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@opentelemetry/api": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser-playwright": { + "optional": true + }, + "@vitest/browser-preview": { + "optional": true + }, + "@vitest/browser-webdriverio": { + "optional": true + }, + "@vitest/coverage-istanbul": { + "optional": true + }, + "@vitest/coverage-v8": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + }, + "vite": { + "optional": false + } + } + }, + "node_modules/why-is-node-running": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-3.2.1.tgz", + "integrity": "sha512-Tb2FUhB4vUsGQlfSquQLYkApkuPAFQXGFzxWKHHumVz2dK+X1RUm/HnID4+TfIGYJ1kTcwOaCk/buYCEJr6YjQ==", + "dev": true, + "license": "MIT", + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=20.11" + } } } } diff --git a/package.json b/package.json index 833be91..8566ed1 100644 --- a/package.json +++ b/package.json @@ -8,7 +8,9 @@ "start": "next start", "typecheck": "tsc --noEmit", "db:deploy": "prisma migrate deploy", - "db:migrate": "prisma migrate dev" + "db:migrate": "prisma migrate dev", + "test": "vitest run", + "test:watch": "vitest" }, "dependencies": { "@fontsource-variable/inter": "^5.2.5", @@ -29,6 +31,7 @@ "@types/node": "^22.10.0", "@types/react": "^19.1.0", "@types/react-dom": "^19.1.0", - "typescript": "^5.9.3" + "typescript": "^5.9.3", + "vitest": "^5.0.5" } } diff --git a/src/app/books/[bookId]/maps/[mapId]/page.tsx b/src/app/books/[bookId]/maps/[mapId]/page.tsx index 05cf068..989f1fa 100644 --- a/src/app/books/[bookId]/maps/[mapId]/page.tsx +++ b/src/app/books/[bookId]/maps/[mapId]/page.tsx @@ -9,9 +9,9 @@ import { fileUrl } from "@/lib/files"; import { requireBook } from "@/lib/session"; // Standard är OpenStreetMaps publika tjänster. Byt via miljövariabler vid tyngre användning. -const TILE_URL = process.env.MAP_TILE_URL ?? "https://tile.openstreetmap.org/{z}/{x}/{y}.png"; -const TILE_ATTRIBUTION = process.env.MAP_TILE_ATTRIBUTION ?? "© OpenStreetMap-bidragsgivare"; -const GEOCODER_URL = process.env.MAP_GEOCODER_URL ?? "https://nominatim.openstreetmap.org/search"; +const TILE_URL = process.env.MAP_TILE_URL || "https://tile.openstreetmap.org/{z}/{x}/{y}.png"; +const TILE_ATTRIBUTION = process.env.MAP_TILE_ATTRIBUTION || "© OpenStreetMap-bidragsgivare"; +const GEOCODER_URL = process.env.MAP_GEOCODER_URL || "https://nominatim.openstreetmap.org/search"; export default async function MapPage({ params, diff --git a/src/lib/backup.ts b/src/lib/backup.ts index 3ad2910..ccf2d20 100644 --- a/src/lib/backup.ts +++ b/src/lib/backup.ts @@ -17,7 +17,14 @@ export const BACKUP_HOUR = Number.isInteger(hour) && hour >= 0 && hour <= 23 ? h export const FOLDER_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/; export const BACKUP_FILE_PATTERN = /^[A-Za-z0-9._-]{1,120}\.(zip|json)$/; -const safeName = (title: string) => title.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-|-$/g, "").slice(0, 50) || "bok"; +// Filnamnet får bara innehålla ASCII, annars avvisas det av nedladdningsrutten. å, ä och ö blir a, a och o. +export const safeName = (title: string) => + title + .normalize("NFD") + .replace(/[̀-ͯ]/g, "") + .replace(/[^A-Za-z0-9]+/g, "-") + .replace(/^-|-$/g, "") + .slice(0, 50) || "bok"; /** Kör en säkerhetskopiering av alla böcker. Returnerar körningens id. */ export async function runBackup(trigger: "schedule" | "manual"): Promise { @@ -41,7 +48,7 @@ export async function runBackup(trigger: "schedule" | "manual"): Promise const entries: Zippable = { "book.json": strToU8(JSON.stringify(data)) }; for (const [name, content] of files) entries[`files/${name}`] = [content, { level: 0 }]; const zip = zipSync(entries); - const file = `${safeName(book.title)}-${book.id.slice(0, 8)}.zip`; + const file = `${safeName(book.title)}-${book.id.slice(-8)}.zip`; await writeFile(path.join(dir, file), zip); bytes += zip.length; index.push({ bookId: book.id, title: book.title, owner: book.owner.name ?? book.owner.email, file, megabytes: Math.round((zip.length / 1048576) * 100) / 100 }); diff --git a/src/lib/name-stats.ts b/src/lib/name-stats.ts index 51a8bf5..f0ad63e 100644 --- a/src/lib/name-stats.ts +++ b/src/lib/name-stats.ts @@ -22,7 +22,7 @@ const REFRESH_AFTER_MS = 90 * 24 * 60 * 60 * 1000; export const maxYear = () => new Date().getFullYear() - 1; /** Gör SCB:s versaler (JACOB, MOHAMMAD) till vanlig skrivning och slår ihop dubbletter. */ -function normalize(raw: string): string | null { +export function normalizeName(raw: string): string | null { const name = raw.trim(); if (!name || name.length > 30 || /[\d\s]/.test(name) || !/^[\p{L}'-]+$/u.test(name)) return null; return name @@ -37,7 +37,7 @@ function toEntries(counts: Map, keep?: number): Entry[] { } function add(counts: Map, rawName: string, rawCount: unknown) { - const name = normalize(rawName); + const name = normalizeName(rawName); const count = Number(rawCount); if (!name || !Number.isFinite(count) || count <= 0) return; counts.set(name, (counts.get(name) ?? 0) + count); diff --git a/src/lib/security.ts b/src/lib/security.ts index 0dc107c..6a9fed3 100644 --- a/src/lib/security.ts +++ b/src/lib/security.ts @@ -16,8 +16,8 @@ function origin(url: string | undefined): string | null { export function contentSecurityPolicy(): string { const dev = process.env.NODE_ENV !== "production"; - const tiles = origin(process.env.MAP_TILE_URL ?? "https://tile.openstreetmap.org/{z}/{x}/{y}.png"); - const geocoder = origin(process.env.MAP_GEOCODER_URL ?? "https://nominatim.openstreetmap.org/search"); + const tiles = origin(process.env.MAP_TILE_URL || "https://tile.openstreetmap.org/{z}/{x}/{y}.png"); + const geocoder = origin(process.env.MAP_GEOCODER_URL || "https://nominatim.openstreetmap.org/search"); const directives: Record = { "default-src": ["'self'"], diff --git a/tests/db-url.mts b/tests/db-url.mts new file mode 100644 index 0000000..0c18e1a --- /dev/null +++ b/tests/db-url.mts @@ -0,0 +1,25 @@ +// Testdatabasens adress: TEST_DATABASE_URL, annars databasen i DATABASE_URL med "_test" efter namnet. +// Testerna tömmer tabellerna, så databasens namn MÅSTE sluta på _test. Annars avbryts allt. +export function testDatabaseUrl(env: NodeJS.ProcessEnv = process.env): string | undefined { + const explicit = env.TEST_DATABASE_URL; + const base = env.DATABASE_URL; + let url: URL; + try { + if (explicit) { + url = new URL(explicit); + } else if (base) { + url = new URL(base); + // Redan en testdatabas (t.ex. när konfigurationen läses igen i en testprocess): lämna som den är + if (!decodeURIComponent(url.pathname.slice(1)).endsWith("_test")) url.pathname = `${url.pathname.replace(/\/$/, "")}_test`; + } else { + return undefined; + } + } catch { + return undefined; + } + const name = decodeURIComponent(url.pathname.slice(1)); + if (!name.endsWith("_test")) { + throw new Error(`Testdatabasens namn måste sluta på _test (fick "${name}"). Testerna tömmer tabellerna.`); + } + return url.toString(); +} diff --git a/tests/db/backup.test.ts b/tests/db/backup.test.ts new file mode 100644 index 0000000..3c1b9a7 --- /dev/null +++ b/tests/db/backup.test.ts @@ -0,0 +1,135 @@ +import { mkdir, readFile } from "node:fs/promises"; +import path from "node:path"; +import { beforeEach, describe, expect, it } from "vitest"; +import { BACKUP_DIR, BACKUP_FILE_PATTERN, BACKUP_KEEP, backupDue, failStaleRuns, listBackups, runBackup, safeName } from "@/lib/backup"; +import { importBook, readImportFile } from "@/lib/book-transfer"; +import { saveImageBytes } from "@/lib/files"; +import { makeImage } from "../helpers/fixtures"; +import { describeDb, makeBook, makeEntity, makeRelation, makeUser, prisma, resetAll } from "../helpers/db"; + +describeDb("säkerhetskopiering", () => { + let ownerId: string; + + beforeEach(async () => { + await resetAll(); + ownerId = (await makeUser()).id; + }); + + it("sparar en zip per bok och en indexfil, och loggar körningen", async () => { + const image = await saveImageBytes(await makeImage(60, 40, "png")); + const a = await makeBook(ownerId, "Första boken"); + const b = await makeBook(ownerId, "Andra boken"); + await makeEntity(a.id, "CHARACTER", "Anna", { imageFile: image }); + await makeEntity(b.id, "CHARACTER", "Bo"); + + const runId = await runBackup("manual"); + const run = await prisma.backupRun.findUniqueOrThrow({ where: { id: runId } }); + expect(run).toMatchObject({ status: "ok", trigger: "manual", books: 2, error: null }); + expect(run.finishedAt).not.toBeNull(); + + const [folder] = await listBackups(); + expect(folder.folder).toBe(run.folder); + // Filnamnen är ASCII (Första blir Forsta), annars kan de inte listas eller laddas ner + expect(folder.files.map((f) => f.name).sort()).toEqual([`Andra-boken-${b.id.slice(-8)}.zip`, `Forsta-boken-${a.id.slice(-8)}.zip`, "index.json"].sort()); + + const index = JSON.parse(await readFile(path.join(BACKUP_DIR, folder.folder, "index.json"), "utf8")) as { books: { title: string; file: string }[] }; + expect(index.books.map((x) => x.title)).toEqual(["Första boken", "Andra boken"]); + }); + + it("filnamn av boktitlar blir alltid giltiga för nedladdning", () => { + expect(safeName("Skuggor över Lund")).toBe("Skuggor-over-Lund"); + expect(safeName("Åsa & Örjan: del 2")).toBe("Asa-Orjan-del-2"); + expect(safeName(" ")).toBe("bok"); + expect(safeName("日本語")).toBe("bok"); + expect(safeName("x".repeat(200))).toHaveLength(50); + for (const title of ["Skuggor över Lund", "Åsa/Örjan", "../../etc/passwd", "a b.c"]) { + expect(`${safeName(title)}-cmvabcde.zip`).toMatch(BACKUP_FILE_PATTERN); + } + }); + + it("zip-filerna går att importera igen, med bilder", async () => { + const image = await saveImageBytes(await makeImage(60, 40, "png")); + const book = await makeBook(ownerId, "Min bok"); + const anna = await makeEntity(book.id, "CHARACTER", "Anna", { imageFile: image }); + const erik = await makeEntity(book.id, "CHARACTER", "Erik"); + await makeRelation(book.id, anna.id, erik.id); + + await runBackup("schedule"); + const [folder] = await listBackups(); + const zip = folder.files.find((f) => f.name.endsWith(".zip"))!; + const { data, files } = readImportFile(new Uint8Array(await readFile(path.join(BACKUP_DIR, folder.folder, zip.name)))); + const result = await importBook(ownerId, data, files); + + expect(result).toMatchObject({ entities: 2, relations: 1, skippedImages: 0 }); + expect((await prisma.entity.findFirstOrThrow({ where: { bookId: result.bookId, name: "Anna" } })).imageFile).toBeTruthy(); + }); + + it("fungerar även utan några böcker", async () => { + const runId = await runBackup("schedule"); + expect(await prisma.backupRun.findUniqueOrThrow({ where: { id: runId } })).toMatchObject({ status: "ok", books: 0 }); + }); + + it(`behåller bara de ${BACKUP_KEEP} senaste körningarna`, async () => { + await makeBook(ownerId, "Bok"); + // Äldre mappar med tidsstämpelnamn, äldre än dagens körning + for (let day = 1; day <= BACKUP_KEEP + 1; day++) { + await mkdir(path.join(BACKUP_DIR, `2020-01-${String(day).padStart(2, "0")}T03-00-00`), { recursive: true }); + } + await runBackup("schedule"); + + const folders = (await listBackups()).map((f) => f.folder); + expect(folders).toHaveLength(BACKUP_KEEP); + expect(folders).not.toContain("2020-01-01T03-00-00"); // äldst är borttagen + expect(folders).not.toContain("2020-01-02T03-00-00"); + expect(folders[0] > "2020").toBe(true); // nyaste först + }); + + it("listBackups ignorerar mappar och filer som inte är säkerhetskopior", async () => { + await mkdir(path.join(BACKUP_DIR, "vad-som-helst"), { recursive: true }); + await mkdir(path.join(BACKUP_DIR, "2021-05-05T03-00-00"), { recursive: true }); + const folders = await listBackups(); + expect(folders.map((f) => f.folder)).toEqual(["2021-05-05T03-00-00"]); + }); + + describe("backupDue", () => { + const at = (hour: number) => new Date(2026, 5, 15, hour, 0, 0); + const runAt = (hour: number, status: string) => prisma.backupRun.create({ data: { trigger: "schedule", status, startedAt: at(hour) } }); + + it("är inte aktuell före inställd timme", async () => { + expect(await backupDue(at(2))).toBe(false); + }); + + it("är aktuell efter inställd timme när ingen körning gjorts i dag", async () => { + expect(await backupDue(at(3))).toBe(true); + expect(await backupDue(at(23))).toBe(true); + }); + + it("är inte aktuell när en körning redan lyckats eller pågår i dag", async () => { + await runAt(3, "ok"); + expect(await backupDue(at(10))).toBe(false); + }); + + it("pågående körning hindrar en ny", async () => { + await runAt(4, "running"); + expect(await backupDue(at(10))).toBe(false); + }); + + it("försöker igen efter en misslyckad körning", async () => { + await runAt(3, "error"); + expect(await backupDue(at(10))).toBe(true); + }); + + it("en körning från igår räknas inte", async () => { + await prisma.backupRun.create({ data: { trigger: "schedule", status: "ok", startedAt: new Date(2026, 5, 14, 3, 0, 0) } }); + expect(await backupDue(at(10))).toBe(true); + }); + }); + + it("markerar körningar som fastnat som misslyckade", async () => { + const stale = await prisma.backupRun.create({ data: { trigger: "schedule", status: "running", startedAt: new Date(Date.now() - 2 * 3600_000) } }); + const fresh = await prisma.backupRun.create({ data: { trigger: "manual", status: "running" } }); + await failStaleRuns(); + expect((await prisma.backupRun.findUniqueOrThrow({ where: { id: stale.id } })).status).toBe("error"); + expect((await prisma.backupRun.findUniqueOrThrow({ where: { id: fresh.id } })).status).toBe("running"); + }); +}); diff --git a/tests/db/history-and-fields.test.ts b/tests/db/history-and-fields.test.ts new file mode 100644 index 0000000..74dea45 --- /dev/null +++ b/tests/db/history-and-fields.test.ts @@ -0,0 +1,114 @@ +import { beforeEach, expect, it } from "vitest"; +import { collectFieldData } from "@/lib/field-values"; +import { MAX_VERSIONS, recordVersion } from "@/lib/history"; +import type { FieldDef } from "@/lib/templates"; +import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db"; + +describeDb("historik", () => { + let userId: string; + let bookId: string; + let entityId: string; + + beforeEach(async () => { + await resetAll(); + userId = (await makeUser()).id; + bookId = (await makeBook(userId)).id; + entityId = (await makeEntity(bookId, "CHARACTER", "Anna")).id; + }); + + it("sparar versionen med den som ändrade", async () => { + await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: "Gammal", summary: null, tags: [], data: {} })); + const [version] = await prisma.entityVersion.findMany({ where: { entityId } }); + expect(version).toMatchObject({ bookId, entityId, userId }); + expect(version.snapshot).toMatchObject({ name: "Gammal" }); + }); + + it(`behåller bara de ${MAX_VERSIONS} senaste versionerna`, async () => { + for (let i = 1; i <= MAX_VERSIONS + 5; i++) { + await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: `v${i}`, summary: null, tags: [], data: {} })); + } + const versions = await prisma.entityVersion.findMany({ where: { entityId }, orderBy: { createdAt: "asc" } }); + expect(versions).toHaveLength(MAX_VERSIONS); + const names = versions.map((v) => (v.snapshot as { name: string }).name); + expect(names[0]).toBe("v6"); // de fem äldsta är borta + expect(names.at(-1)).toBe(`v${MAX_VERSIONS + 5}`); + }); + + it("rensar bara den aktuella postens versioner", async () => { + const other = await makeEntity(bookId, "CHARACTER", "Bo"); + for (let i = 0; i < MAX_VERSIONS + 2; i++) { + await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: `a${i}`, summary: null, tags: [], data: {} })); + } + await prisma.$transaction((tx) => recordVersion(tx, bookId, other.id, userId, { name: "b", summary: null, tags: [], data: {} })); + expect(await prisma.entityVersion.count({ where: { entityId: other.id } })).toBe(1); + }); + + it("följer med när boken tas bort", async () => { + await prisma.$transaction((tx) => recordVersion(tx, bookId, entityId, userId, { name: "x", summary: null, tags: [], data: {} })); + await prisma.book.delete({ where: { id: bookId } }); + expect(await prisma.entityVersion.count()).toBe(0); + }); +}); + +describeDb("fältvärden från formulär", () => { + let bookId: string; + let premisesId: string; + let characterId: string; + let foreignPremisesId: string; + + const fields: FieldDef[] = [ + { key: "name", label: "Text", type: "text" }, + { key: "age", label: "Ålder", type: "number" }, + { key: "alive", label: "Vid liv", type: "checkbox" }, + { key: "premises", label: "Lokal", type: "reference", refKind: "PREMISES" }, + { key: "anything", label: "Vad som helst", type: "reference" }, + ]; + const form = (values: Record) => { + const data = new FormData(); + for (const [key, value] of Object.entries(values)) data.set(`f_${key}`, value); + return data; + }; + + beforeEach(async () => { + await resetAll(); + const user = await makeUser(); + bookId = (await makeBook(user.id)).id; + premisesId = (await makeEntity(bookId, "PREMISES", "Lokal")).id; + characterId = (await makeEntity(bookId, "CHARACTER", "Anna")).id; + foreignPremisesId = (await makeEntity((await makeBook(user.id, "Annan")).id, "PREMISES", "Främmande")).id; + }); + + it("läser text, tal och kryssrutor", async () => { + const data = await collectFieldData(bookId, fields, form({ name: " Anna ", age: "1,5", alive: "on" }), null); + expect(data).toMatchObject({ name: "Anna", age: 1.5, alive: true }); + }); + + it("en ibockad kryssruta som saknas i formuläret blir falsk", async () => { + const data = await collectFieldData(bookId, fields, form({ name: "x" }), { alive: true }); + expect(data.alive).toBe(false); + }); + + it("tomma fält tas bort och ogiltiga tal ignoreras", async () => { + const data = await collectFieldData(bookId, fields, form({ name: "", age: "abc" }), { name: "gammal", age: 5 }); + expect(data.name).toBeUndefined(); + expect(data.age).toBe(5); // behåller det tidigare värdet när det nya inte är ett tal + }); + + it("låter data för fält som inte finns i mallen vara orörd", async () => { + const data = await collectFieldData(bookId, fields, form({ name: "x" }), { gammalt: "kvar" }); + expect(data.gammalt).toBe("kvar"); + }); + + it("godkänner en koppling till rätt typ av post i boken", async () => { + const data = await collectFieldData(bookId, fields, form({ premises: premisesId, anything: characterId }), null); + expect(data.premises).toBe(premisesId); + expect(data.anything).toBe(characterId); + }); + + it("tar bort kopplingar till fel typ, andra böcker och poster som inte finns", async () => { + for (const value of [characterId, foreignPremisesId, "finns-inte"]) { + const data = await collectFieldData(bookId, fields, form({ premises: value }), null); + expect(data.premises).toBeUndefined(); + } + }); +}); diff --git a/tests/db/ids.test.ts b/tests/db/ids.test.ts new file mode 100644 index 0000000..4f213f2 --- /dev/null +++ b/tests/db/ids.test.ts @@ -0,0 +1,50 @@ +import { beforeEach, expect, it } from "vitest"; +import { nextEntityCode, nextMapCode, nextMarkerCode, nextRelationCode, nextScheduleCode } from "@/lib/ids"; +import { describeDb, makeBook, makeUser, prisma, resetAll } from "../helpers/db"; + +describeDb("löpande ID", () => { + let bookId: string; + let otherBookId: string; + + beforeEach(async () => { + await resetAll(); + const user = await makeUser(); + bookId = (await makeBook(user.id, "A")).id; + otherBookId = (await makeBook(user.id, "B")).id; + }); + + it("räknar upp per typ i varje bok", async () => { + expect(await nextEntityCode(bookId, "CHARACTER")).toBe("KI-0001"); + expect(await nextEntityCode(bookId, "CHARACTER")).toBe("KI-0002"); + expect(await nextEntityCode(bookId, "PET")).toBe("DI-0001"); + expect(await nextEntityCode(bookId, "CHARACTER")).toBe("KI-0003"); + }); + + it("börjar om i en ny bok", async () => { + await nextEntityCode(bookId, "CHARACTER"); + await nextEntityCode(bookId, "CHARACTER"); + expect(await nextEntityCode(otherBookId, "CHARACTER")).toBe("KI-0001"); + }); + + it("ger inget ID åt typer utan ID", async () => { + expect(await nextEntityCode(bookId, "APP")).toBeNull(); + expect(await nextEntityCode(bookId, "WEBSITE")).toBeNull(); + expect(await prisma.idCounter.count({ where: { bookId } })).toBe(0); + }); + + it("använder egna räknare för relationer, placeringar, scheman och kartor", async () => { + expect(await nextRelationCode(bookId)).toBe("REI-0001"); + expect(await nextMarkerCode(bookId)).toBe("PI-0001"); + expect(await nextScheduleCode(bookId)).toBe("SCI-0001"); + expect(await nextMapCode(bookId, "GEO")).toBe("KD-R_0001"); + expect(await nextMapCode(bookId, "IMAGE")).toBe("KD-E_0001"); + expect(await nextMapCode(bookId, "GEO")).toBe("KD-R_0002"); + }); + + it("ger unika nummer även när många skapas samtidigt", async () => { + const codes = await Promise.all(Array.from({ length: 25 }, () => nextEntityCode(bookId, "CHARACTER"))); + expect(new Set(codes).size).toBe(25); + expect(codes.sort()[0]).toBe("KI-0001"); + expect(codes.sort()[24]).toBe("KI-0025"); + }); +}); diff --git a/tests/db/storage-admin-search.test.ts b/tests/db/storage-admin-search.test.ts new file mode 100644 index 0000000..1dc0df6 --- /dev/null +++ b/tests/db/storage-admin-search.test.ts @@ -0,0 +1,149 @@ +import { beforeEach, describe, expect, it, vi } from "vitest"; +import { isAdminUser } from "@/lib/admin"; +import { saveImageBytes } from "@/lib/files"; +import { trashEntity } from "@/lib/trash"; +import { userImageNames, userStorageBytes } from "@/lib/storage"; +import { makeImage } from "../helpers/fixtures"; +import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db"; + +// Sökvägen använder inloggningen. Här byter vi ut den mot en användare som testet väljer. +const current = vi.hoisted(() => ({ userId: "" as string | null })); +vi.mock("@/lib/session", () => ({ getCurrentUser: async () => (current.userId ? { id: current.userId } : null) })); + +describeDb("lagringskvot", () => { + beforeEach(resetAll); + + it("räknar bilder på poster, kartor och i papperskorgen, men bara användarens egna", async () => { + const me = await makeUser("Jag"); + const other = await makeUser("Annan"); + const mine = await makeBook(me.id); + const theirs = await makeBook(other.id); + + const a = await saveImageBytes(await makeImage(100, 100, "png")); + const b = await saveImageBytes(await makeImage(120, 120, "png"), "map"); + const c = await saveImageBytes(await makeImage(80, 80, "png")); + const foreign = await saveImageBytes(await makeImage(90, 90, "png")); + + await makeEntity(mine.id, "CHARACTER", "Med bild", { imageFile: a }); + await prisma.bookMap.create({ data: { bookId: mine.id, name: "K", kind: "IMAGE", imageFile: b } }); + const inTrash = await makeEntity(mine.id, "CHARACTER", "Borttagen", { imageFile: c }); + await trashEntity(me.id, mine.id, inTrash.id); + await makeEntity(theirs.id, "CHARACTER", "Någon annans", { imageFile: foreign }); + + expect((await userImageNames(me.id)).sort()).toEqual([a!, b!, c!].sort()); + expect(await userStorageBytes(me.id)).toBeGreaterThan(0); + expect(await userStorageBytes(other.id)).toBeLessThan(await userStorageBytes(me.id)); + }); + + it("räknar noll utan bilder", async () => { + const user = await makeUser(); + expect(await userStorageBytes(user.id)).toBe(0); + }); + + it("withinQuota följer USER_QUOTA_MB", async () => { + vi.stubEnv("USER_QUOTA_MB", "0.0001"); // cirka 100 byte + vi.resetModules(); + const { withinQuota, USER_QUOTA_BYTES } = await import("@/lib/storage"); + expect(USER_QUOTA_BYTES).toBeLessThan(200); + + const user = await makeUser(); + const book = await makeBook(user.id); + expect(await withinQuota(user.id, 50)).toBe(true); + expect(await withinQuota(user.id, 5000)).toBe(false); + + const { saveImageBytes: save } = await import("@/lib/files"); + const image = await save(await makeImage(300, 300, "png")); + await prisma.entity.create({ data: { bookId: book.id, kind: "CHARACTER", name: "X", imageFile: image } }); + expect(await withinQuota(user.id, 1)).toBe(false); // bilden ensam överskrider redan kvoten + vi.unstubAllEnvs(); + vi.resetModules(); + }); +}); + +describeDb("administratör", () => { + beforeEach(resetAll); + + it("den äldsta användaren är administratör när ADMIN_EMAILS saknas", async () => { + const first = await makeUser("Först"); + const second = await makeUser("Sist"); + expect(await isAdminUser(first.id, first.email)).toBe(true); + expect(await isAdminUser(second.id, second.email)).toBe(false); + }); + + it("ADMIN_EMAILS styr när den är satt, oberoende av stora bokstäver och mellanslag", async () => { + const first = await makeUser("Först", "forst@example.com"); + const second = await makeUser("Sist", "Sist@Example.com"); + vi.stubEnv("ADMIN_EMAILS", " sist@example.com , annan@example.com "); + expect(await isAdminUser(second.id, second.email)).toBe(true); + expect(await isAdminUser(first.id, first.email)).toBe(false); // äldst, men inte i listan + expect(await isAdminUser(first.id, null)).toBe(false); + vi.unstubAllEnvs(); + }); +}); + +describeDb("sök", () => { + let bookId: string; + let userId: string; + const search = async (q: string, book = bookId) => { + const { GET } = await import("@/app/api/books/[bookId]/search/route"); + return GET(new Request(`http://localhost/api/books/${book}/search?q=${encodeURIComponent(q)}`, { headers: { "x-forwarded-for": `10.0.0.${Math.floor(Math.random() * 250)}` } }), { + params: Promise.resolve({ bookId: book }), + }); + }; + const names = async (q: string) => ((await (await search(q)).json()) as { results: { name: string }[] }).results.map((r) => r.name); + + beforeEach(async () => { + await resetAll(); + userId = (await makeUser()).id; + current.userId = userId; + bookId = (await makeBook(userId)).id; + await makeEntity(bookId, "CHARACTER", "Anna Lindqvist", { tags: ["huvudperson"], summary: "En bagare i Lund", data: { occupation: "Bagare", nickname: "Annie" } }); + await makeEntity(bookId, "CHARACTER", "Erik Berg", { data: { occupation: "Barista" } }); + await makeEntity(bookId, "PLACE", "100% Kaffe"); + }); + + it("hittar på namn, ID, sammanfattning, taggar och värden i mallfält", async () => { + expect(await names("lindqvist")).toEqual(["Anna Lindqvist"]); + expect(await names("KI-0002")).toEqual(["Erik Berg"]); + expect(await names("bagare i lund")).toEqual(["Anna Lindqvist"]); + expect(await names("huvudperson")).toEqual(["Anna Lindqvist"]); + expect(await names("barista")).toEqual(["Erik Berg"]); + expect(await names("annie")).toEqual(["Anna Lindqvist"]); + }); + + it("söker i fältens värden men inte i deras nycklar", async () => { + expect(await names("occupation")).toEqual([]); + expect(await names("nickname")).toEqual([]); + }); + + it("behandlar procenttecken och understreck som vanliga tecken", async () => { + expect(await names("100%")).toEqual(["100% Kaffe"]); + expect(await names("%%")).toEqual([]); + expect(await names("A_n")).toEqual([]); // _ är inte jokertecken + }); + + it("sorterar träffar som börjar med söktexten först", async () => { + await makeEntity(bookId, "CHARACTER", "Maria Anna"); + expect((await names("anna"))[0]).toBe("Anna Lindqvist"); + }); + + it("kräver minst två tecken", async () => { + expect(await names("a")).toEqual([]); + }); + + it("nekar andra användare och utloggade", async () => { + const intruder = await makeUser("Inkräktare"); + current.userId = intruder.id; + expect((await search("anna")).status).toBe(404); + current.userId = null; + expect((await search("anna")).status).toBe(401); + }); +}); + +describe("hjälpare", () => { + it("testfilerna körs i en egen tillfällig mapp, inte i projektets data", () => { + expect(process.env.UPLOAD_DIR).toContain("bookmanager-test-data"); + expect(process.env.BACKUP_DIR).toContain("bookmanager-test-data"); + expect(process.env.TRASH_DIR).toContain("bookmanager-test-data"); + }); +}); diff --git a/tests/db/transfer.test.ts b/tests/db/transfer.test.ts new file mode 100644 index 0000000..3c2ee87 --- /dev/null +++ b/tests/db/transfer.test.ts @@ -0,0 +1,189 @@ +import { readFile } from "node:fs/promises"; +import path from "node:path"; +import { strToU8, zipSync, type Zippable } from "fflate"; +import { beforeEach, expect, it } from "vitest"; +import { buildExport, importBook, readImportFile } from "@/lib/book-transfer"; +import { UPLOAD_DIR, saveImageBytes } from "@/lib/files"; +import { nextMapCode, nextMarkerCode, nextScheduleCode } from "@/lib/ids"; +import { entityRow, makeImage, validExport } from "../helpers/fixtures"; +import { describeDb, filesIn, makeBook, makeEntity, makeRelation, makeUser, prisma, resetAll } from "../helpers/db"; + +/** Skickar exporten genom samma zip-format som exportknappen och läser tillbaka den. */ +function viaZip(exported: Awaited>) { + const entries: Zippable = { "book.json": strToU8(JSON.stringify(exported.data)) }; + for (const [name, bytes] of exported.files) entries[`files/${name}`] = [bytes, { level: 0 }]; + return readImportFile(zipSync(entries)); +} + +describeDb("export och import", () => { + let ownerId: string; + let bookId: string; + const ids = {} as Record<"anna" | "erik" | "cafe" | "firma" | "relation" | "map", string>; + + /** En bok med allt: bilder, relation med deltagare, kopplingsfält, scheman, kartor och mall. */ + beforeEach(async () => { + await resetAll(); + ownerId = (await makeUser("Ägare")).id; + bookId = (await makeBook(ownerId, "Testbok")).id; + + const portrait = await saveImageBytes(await makeImage(120, 80, "png")); + const anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: portrait, tags: ["huvud"], summary: "Huvudperson", data: { age: 30 } }); + const erik = await makeEntity(bookId, "CHARACTER", "Erik"); + const cafe = await makeEntity(bookId, "PREMISES", "Café Lund"); + const firma = await makeEntity(bookId, "COMPANY", "Lunds Kaffe", { data: { industry: "Kaffe", premises: cafe.id } }); + const relation = await makeRelation(bookId, anna.id, erik.id, "Vänner", [cafe.id]); + + const scheduleCode = await nextScheduleCode(bookId); + await prisma.shift.createMany({ + data: [0, 1].map((weekday) => ({ bookId, personId: erik.id, workplaceId: cafe.id, weekday, startTime: "08:00", endTime: "16:00", scheduleCode })), + }); + + const mapImage = await saveImageBytes(await makeImage(200, 100, "png"), "map"); + const geo = await prisma.bookMap.create({ data: { bookId, name: "Lund", kind: "GEO", code: await nextMapCode(bookId, "GEO"), centerLat: 55.7, centerLng: 13.19, zoom: 14 } }); + await prisma.bookMap.create({ data: { bookId, name: "Egen", kind: "IMAGE", code: await nextMapCode(bookId, "IMAGE"), imageFile: mapImage } }); + await prisma.marker.create({ data: { mapId: geo.id, entityId: cafe.id, label: "Café", code: await nextMarkerCode(bookId), lat: 55.7047, lng: 13.191, color: "orange", note: "Hörnet" } }); + await prisma.template.create({ data: { bookId, kind: "CHARACTER", fields: [{ key: "mood", label: "Läge", type: "text" }] } }); + + Object.assign(ids, { anna: anna.id, erik: erik.id, cafe: cafe.id, firma: firma.id, relation: relation.id, map: geo.id }); + }); + + it("en export som importeras igen blir en likadan bok med nya id", async () => { + const exported = await buildExport(bookId, true); + const { data, files } = viaZip(exported); + const result = await importBook(ownerId, data, files); + + expect(result).toMatchObject({ entities: 4, relations: 1, maps: 2, markers: 1, shifts: 2, skippedImages: 0, skippedLinks: 0 }); + expect(result.bookId).not.toBe(bookId); + + const copy = await prisma.book.findUniqueOrThrow({ + where: { id: result.bookId }, + include: { entities: true, relations: { include: { members: true } }, shifts: true, maps: { include: { markers: true } }, templates: true, counters: true }, + }); + // Samma titel får ett tillägg så att böckerna går att skilja åt + expect(copy.title).toBe("Testbok (import)"); + + // Poster: nya id, men samma namn, ID-nummer, taggar och mallfält + const byName = Object.fromEntries(copy.entities.map((e) => [e.name, e])); + expect(Object.keys(byName).sort()).toEqual(["Anna", "Café Lund", "Erik", "Lunds Kaffe"]); + expect(byName.Anna).toMatchObject({ code: "KI-0001", tags: ["huvud"], summary: "Huvudperson", data: { age: 30 } }); + expect(byName["Café Lund"].code).toBe("LI-0001"); + for (const old of Object.values(ids)) expect(copy.entities.map((e) => e.id)).not.toContain(old); + + // Kopplingsfältet pekar på den nya lokalen, inte den gamla + expect((byName["Lunds Kaffe"].data as { premises: string }).premises).toBe(byName["Café Lund"].id); + + // Relationen och dess extra deltagare pekar på de nya posterna + const [relation] = copy.relations; + expect(relation).toMatchObject({ code: "REI-0001", type: "Vänner", fromId: byName.Anna.id, toId: byName.Erik.id }); + expect(relation.members.map((m) => m.entityId)).toEqual([byName["Café Lund"].id]); + + // Scheman delar schema-ID och pekar på nya poster + expect(copy.shifts).toHaveLength(2); + expect(new Set(copy.shifts.map((s) => s.scheduleCode))).toEqual(new Set(["SCI-0001"])); + expect(copy.shifts.every((s) => s.personId === byName.Erik.id && s.workplaceId === byName["Café Lund"].id)).toBe(true); + + // Kartor och markeringar + const geo = copy.maps.find((m) => m.kind === "GEO")!; + expect(geo).toMatchObject({ code: "KD-R_0001", zoom: 14, centerLat: 55.7 }); + expect(geo.markers[0]).toMatchObject({ code: "PI-0001", label: "Café", color: "orange", note: "Hörnet", entityId: byName["Café Lund"].id }); + expect(copy.maps.find((m) => m.kind === "IMAGE")?.code).toBe("KD-E_0001"); + + // Mall och räknare + expect(copy.templates).toHaveLength(1); + const counter = Object.fromEntries(copy.counters.map((c) => [c.key, c.next])); + expect(counter).toMatchObject({ KI: 2, LI: 1, FI: 1, REI: 1, SCI: 1, PI: 1, "KD-R": 1, "KD-E": 1 }); + }); + + it("bilderna kopieras till nya filer", async () => { + const before = await filesIn(UPLOAD_DIR); + expect(before).toHaveLength(2); + const { data, files } = viaZip(await buildExport(bookId, true)); + const result = await importBook(ownerId, data, files); + + const after = await filesIn(UPLOAD_DIR); + expect(after).toHaveLength(4); + const copy = await prisma.entity.findFirstOrThrow({ where: { bookId: result.bookId, name: "Anna" } }); + expect(copy.imageFile).toBeTruthy(); + expect(before).not.toContain(copy.imageFile); + expect((await readFile(path.join(UPLOAD_DIR, copy.imageFile!))).length).toBeGreaterThan(0); + }); + + it("nya poster fortsätter numreringen efter importen", async () => { + const { data, files } = viaZip(await buildExport(bookId, true)); + const { bookId: copyId } = await importBook(ownerId, data, files); + const next = await makeEntity(copyId, "CHARACTER", "Ny"); + expect(next.code).toBe("KI-0003"); + }); + + it("JSON utan bilder går att importera", async () => { + const { data } = await buildExport(bookId, false); + const result = await importBook(ownerId, data, new Map()); + expect(result.entities).toBe(4); + expect(result.skippedImages).toBe(0); + expect((await prisma.entity.findFirstOrThrow({ where: { bookId: result.bookId, name: "Anna" } })).imageFile).toBeNull(); + }); + + it("kan importeras till en annan användare utan tillägg i titeln", async () => { + const other = await makeUser("Annan"); + const { data, files } = viaZip(await buildExport(bookId, true)); + const result = await importBook(other.id, data, files); + const copy = await prisma.book.findUniqueOrThrow({ where: { id: result.bookId } }); + expect(copy.ownerId).toBe(other.id); + expect(copy.title).toBe("Testbok"); + }); + + it("saknade bilder och trasiga kopplingar hoppas över och räknas", async () => { + const data = validExport({ + entities: [entityRow("a", "CHARACTER", "Anna", { image: "saknas.png" }), entityRow("b", "CHARACTER", "Bo", { image: "skräp.png" })], + relations: [ + { id: "r1", code: null, fromId: "a", toId: "b", type: "Vänner", description: null, data: {}, members: ["finns-inte"] }, + { id: "r2", code: null, fromId: "a", toId: "okänd", type: "Fiende", description: null, data: {}, members: [] }, + { id: "r3", code: null, fromId: "a", toId: "a", type: "Självrelation", description: null, data: {}, members: [] }, + ], + shifts: [{ personId: "okänd", workplaceId: null, weekday: 0, startTime: "08:00", endTime: "16:00", weeks: "ALL", label: null, scheduleCode: null }], + }); + const files = new Map([["skräp.png", new TextEncoder().encode("det här är ingen bild")]]); + const result = await importBook(ownerId, data, files); + + expect(result).toMatchObject({ entities: 2, relations: 1, shifts: 0, skippedImages: 2, skippedLinks: 3 }); + const relations = await prisma.relation.findMany({ where: { bookId: result.bookId }, include: { members: true } }); + expect(relations).toHaveLength(1); + expect(relations[0].members).toHaveLength(0); + }); + + it("behåller giltiga ID men ger nya åt dubbletter och felaktiga", async () => { + const data = validExport({ + entities: [ + entityRow("a", "CHARACTER", "Anna", { code: "KI-0007" }), + entityRow("b", "CHARACTER", "Bo", { code: "KI-0007" }), // dubblett + entityRow("c", "CHARACTER", "Cia", { code: "FEL-1" }), // fel format + entityRow("d", "CHARACTER", "Dan", { code: "FI-0002" }), // fel prefix för en karaktär + entityRow("e", "CHARACTER", "Eva", { code: null }), + entityRow("f", "APP", "En app", { code: "KI-0001" }), // appar har inget ID + ], + }); + const result = await importBook(ownerId, data, new Map()); + const rows = await prisma.entity.findMany({ where: { bookId: result.bookId }, orderBy: { name: "asc" } }); + const code = (name: string) => rows.find((e) => e.name === name)!.code; + + expect(code("Anna")).toBe("KI-0007"); + expect(code("En app")).toBeNull(); + const assigned = ["Bo", "Cia", "Dan", "Eva"].map(code); + expect(new Set([...assigned, "KI-0007"]).size).toBe(5); // alla unika + expect(assigned.every((c) => /^KI-\d{4}$/.test(c!))).toBe(true); + // Nya nummer fortsätter efter det högsta som användes + expect(assigned.sort()).toEqual(["KI-0008", "KI-0009", "KI-0010", "KI-0011"]); + }); + + it("tar bort de sparade bilderna igen om importen misslyckas", async () => { + const image = await makeImage(40, 40, "png"); + const before = await filesIn(UPLOAD_DIR); + // Samma id två gånger gör att databasen avvisar raderna (unik nyckel) efter att bilderna sparats + const data = validExport({ + entities: [entityRow("dubbel", "CHARACTER", "A", { image: "a.png" }), entityRow("dubbel", "CHARACTER", "B", { image: "b.png" })], + }); + await expect(importBook(ownerId, data, new Map([["a.png", image], ["b.png", image]]))).rejects.toThrow(); + expect(await filesIn(UPLOAD_DIR)).toEqual(before); + expect(await prisma.book.count({ where: { title: "Testbok (import)" } })).toBe(0); + }); +}); diff --git a/tests/db/trash.test.ts b/tests/db/trash.test.ts new file mode 100644 index 0000000..9239f20 --- /dev/null +++ b/tests/db/trash.test.ts @@ -0,0 +1,199 @@ +import { readdir } from "node:fs/promises"; +import { beforeEach, describe, expect, it } from "vitest"; +import { UPLOAD_DIR, saveImageBytes } from "@/lib/files"; +import { nextMapCode, nextMarkerCode, nextScheduleCode } from "@/lib/ids"; +import { TRASH_DIR, TRASH_DAYS, emptyBookTrash, purgeExpiredTrash, purgeTrashItem, restoreBook, restoreEntity, trashBook, trashEntity } from "@/lib/trash"; +import { makeImage } from "../helpers/fixtures"; +import { describeDb, filesIn, makeBook, makeEntity, makeRelation, makeUser, prisma, resetAll } from "../helpers/db"; + +describeDb("papperskorg", () => { + let ownerId: string; + let bookId: string; + let anna: { id: string; code: string | null }; + let erik: { id: string }; + let cafe: { id: string }; + let relationId: string; + let markerId: string; + let hostedShiftId: string; + + beforeEach(async () => { + await resetAll(); + ownerId = (await makeUser()).id; + bookId = (await makeBook(ownerId)).id; + const image = await saveImageBytes(await makeImage(80, 60, "png")); + anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: image, data: { age: 30 } }); + erik = await makeEntity(bookId, "CHARACTER", "Erik"); + cafe = await makeEntity(bookId, "PREMISES", "Café"); + const company = await makeEntity(bookId, "COMPANY", "Firma"); + + // Anna är med i en relation som parti, i en annan som extra deltagare, har egna pass och är arbetsplats åt ett pass + relationId = (await makeRelation(bookId, anna.id, erik.id, "Vänner", [cafe.id])).id; + await makeRelation(bookId, erik.id, company.id, "Jobbar på", [anna.id]); + const code = await nextScheduleCode(bookId); + await prisma.shift.create({ data: { bookId, personId: anna.id, workplaceId: cafe.id, weekday: 0, startTime: "08:00", endTime: "16:00", scheduleCode: code } }); + hostedShiftId = (await prisma.shift.create({ data: { bookId, personId: erik.id, workplaceId: anna.id, weekday: 1, startTime: "09:00", endTime: "17:00", scheduleCode: code } })).id; + const map = await prisma.bookMap.create({ data: { bookId, name: "Karta", kind: "GEO", code: await nextMapCode(bookId, "GEO") } }); + markerId = (await prisma.marker.create({ data: { mapId: map.id, entityId: anna.id, label: "Annas hus", code: await nextMarkerCode(bookId), lat: 1, lng: 2 } })).id; + }); + + describe("poster", () => { + it("flyttar posten till papperskorgen och tar bort den ur boken", async () => { + await trashEntity(ownerId, bookId, anna.id); + expect(await prisma.entity.findUnique({ where: { id: anna.id } })).toBeNull(); + const [item] = await prisma.trashItem.findMany(); + expect(item).toMatchObject({ kind: "entity", label: "Anna", detail: "CHARACTER", ownerId, bookId }); + // Annas relationer och egna pass följer med bort + expect(await prisma.relation.count({ where: { id: relationId } })).toBe(0); + expect(await prisma.shift.count({ where: { personId: anna.id } })).toBe(0); + // Det som bara pekade på henne blir kvar utan koppling + expect((await prisma.shift.findUniqueOrThrow({ where: { id: hostedShiftId } })).workplaceId).toBeNull(); + expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).entityId).toBeNull(); + }); + + it("behåller bilden medan posten ligger i papperskorgen", async () => { + const image = (await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).imageFile!; + await trashEntity(ownerId, bookId, anna.id); + expect(await filesIn(UPLOAD_DIR)).toContain(image); + }); + + it("återställer allt: samma id och ID-nummer, relationer, deltagande, pass, arbetsplats och markering", async () => { + await trashEntity(ownerId, bookId, anna.id); + const [item] = await prisma.trashItem.findMany(); + const restored = await restoreEntity(ownerId, item.id); + expect(restored).toEqual({ bookId, entityId: anna.id }); + + const back = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id }, include: { outgoing: { include: { members: true } }, memberOf: true, shifts: true } }); + expect(back).toMatchObject({ name: "Anna", code: anna.code, data: { age: 30 } }); + expect(back.imageFile).toBeTruthy(); + expect(back.outgoing).toHaveLength(1); + expect(back.outgoing[0].id).toBe(relationId); + expect(back.outgoing[0].members.map((m) => m.entityId)).toEqual([cafe.id]); + expect(back.memberOf).toHaveLength(1); + expect(back.shifts).toHaveLength(1); + expect(back.shifts[0].scheduleCode).toBe("SCI-0001"); + expect((await prisma.shift.findUniqueOrThrow({ where: { id: hostedShiftId } })).workplaceId).toBe(anna.id); + expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).entityId).toBe(anna.id); + expect(await prisma.trashItem.count()).toBe(0); + }); + + it("hoppar över relationer vars andra part tagits bort under tiden", async () => { + await trashEntity(ownerId, bookId, anna.id); + await prisma.entity.delete({ where: { id: erik.id } }); + const [item] = await prisma.trashItem.findMany(); + await restoreEntity(ownerId, item.id); + expect(await prisma.entity.findUnique({ where: { id: anna.id } })).not.toBeNull(); + expect(await prisma.relation.count({ where: { id: relationId } })).toBe(0); + }); + + it("ger en ny kod om den gamla hunnit tas av en annan post", async () => { + await trashEntity(ownerId, bookId, anna.id); + await prisma.entity.update({ where: { id: erik.id }, data: { code: anna.code } }); + const [item] = await prisma.trashItem.findMany(); + await restoreEntity(ownerId, item.id); + const back = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } }); + expect(back.code).toMatch(/^KI-\d{4}$/); + expect(back.code).not.toBe(anna.code); + }); + + it("kan inte återställas av någon annan, eller när boken är borta", async () => { + const intruder = await makeUser("Inkräktare"); + await trashEntity(ownerId, bookId, anna.id); + const [item] = await prisma.trashItem.findMany(); + expect(await restoreEntity(intruder.id, item.id)).toBeNull(); + expect(await prisma.entity.count({ where: { id: anna.id } })).toBe(0); + + await prisma.book.delete({ where: { id: bookId } }); + expect(await restoreEntity(ownerId, item.id)).toBeNull(); + }); + + it("rensar för gott: tar bort bilden och historiken", async () => { + const image = (await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).imageFile!; + await prisma.entityVersion.create({ data: { bookId, entityId: anna.id, snapshot: { name: "Gammal" } } }); + await trashEntity(ownerId, bookId, anna.id); + const [item] = await prisma.trashItem.findMany(); + + await purgeTrashItem(ownerId, item.id); + expect(await prisma.trashItem.count()).toBe(0); + expect(await filesIn(UPLOAD_DIR)).not.toContain(image); + expect(await prisma.entityVersion.count({ where: { entityId: anna.id } })).toBe(0); + }); + + it("kan inte rensa någon annans papperskorg", async () => { + const intruder = await makeUser("Inkräktare"); + await trashEntity(ownerId, bookId, anna.id); + const [item] = await prisma.trashItem.findMany(); + await purgeTrashItem(intruder.id, item.id); + expect(await prisma.trashItem.count()).toBe(1); + }); + + it("tömmer bokens papperskorg men rör inga andra böcker", async () => { + const otherBook = await makeBook(ownerId, "Annan"); + const stray = await makeEntity(otherBook.id, "CHARACTER", "Kvar"); + await trashEntity(ownerId, bookId, erik.id); + await trashEntity(ownerId, otherBook.id, stray.id); + await emptyBookTrash(ownerId, bookId); + const left = await prisma.trashItem.findMany(); + expect(left.map((i) => i.label)).toEqual(["Kvar"]); + }); + + it("rensar bara det som legat längre än gränsen", async () => { + await trashEntity(ownerId, bookId, erik.id); + await trashEntity(ownerId, bookId, cafe.id); + const old = await prisma.trashItem.findFirstOrThrow({ where: { label: "Erik" } }); + await prisma.trashItem.update({ where: { id: old.id }, data: { deletedAt: new Date(Date.now() - (TRASH_DAYS + 1) * 86_400_000) } }); + + expect(await purgeExpiredTrash()).toBe(1); + expect((await prisma.trashItem.findMany()).map((i) => i.label)).toEqual(["Café"]); + }); + }); + + describe("böcker", () => { + it("sparar boken som zip med bilderna och tar bort den", async () => { + expect(await filesIn(UPLOAD_DIR)).toHaveLength(1); + await trashBook(ownerId, bookId); + + expect(await prisma.book.count()).toBe(0); + const [item] = await prisma.trashItem.findMany(); + expect(item).toMatchObject({ kind: "book", label: "Testbok", ownerId }); + expect(await readdir(TRASH_DIR)).toEqual([item.file]); + // Bilden ligger nu i zip-filen och inte längre bland de uppladdade + expect(await filesIn(UPLOAD_DIR)).toHaveLength(0); + }); + + it("återställer boken som en ny bok med allt innehåll och bilderna", async () => { + await trashBook(ownerId, bookId); + const [item] = await prisma.trashItem.findMany(); + const newId = await restoreBook(ownerId, item.id); + + expect(newId).toBeTruthy(); + const book = await prisma.book.findUniqueOrThrow({ where: { id: newId! }, include: { entities: true, relations: true, shifts: true, maps: { include: { markers: true } } } }); + expect(book.title).toBe("Testbok"); + expect(book.entities).toHaveLength(4); + expect(book.relations).toHaveLength(2); + expect(book.shifts).toHaveLength(2); + expect(book.maps[0].markers).toHaveLength(1); + expect(book.entities.find((e) => e.name === "Anna")?.code).toBe(anna.code); + expect(await filesIn(UPLOAD_DIR)).toHaveLength(1); + + // Papperskorgen och zip-filen är borta + expect(await prisma.trashItem.count()).toBe(0); + expect(await readdir(TRASH_DIR)).toEqual([]); + }); + + it("kan inte återställas av någon annan", async () => { + const intruder = await makeUser("Inkräktare"); + await trashBook(ownerId, bookId); + const [item] = await prisma.trashItem.findMany(); + expect(await restoreBook(intruder.id, item.id)).toBeNull(); + expect(await prisma.book.count()).toBe(0); + }); + + it("rensar zip-filen när den tas bort för gott", async () => { + await trashBook(ownerId, bookId); + const [item] = await prisma.trashItem.findMany(); + await purgeTrashItem(ownerId, item.id); + expect(await readdir(TRASH_DIR)).toEqual([]); + expect(await prisma.trashItem.count()).toBe(0); + }); + }); +}); diff --git a/tests/global-setup.ts b/tests/global-setup.ts new file mode 100644 index 0000000..dba7fd7 --- /dev/null +++ b/tests/global-setup.ts @@ -0,0 +1,41 @@ +import { execSync } from "node:child_process"; +import { mkdir, rm } from "node:fs/promises"; +import os from "node:os"; +import path from "node:path"; +import { PrismaClient } from "@prisma/client"; +import { testDatabaseUrl } from "./db-url.mts"; + +// Körs en gång före alla tester: skapar testdatabasen om den saknas, kör migreringarna och städar filmapparna. +// Hoppar över databasen helt om ingen testdatabas är konfigurerad (databastesterna hoppas då över). +export default async function setup() { + const dataDir = path.join(os.tmpdir(), "bookmanager-test-data"); + await rm(dataDir, { recursive: true, force: true }); + await mkdir(dataDir, { recursive: true }); + + const databaseUrl = testDatabaseUrl(); + if (!databaseUrl) { + console.warn("\n[tester] Ingen databas konfigurerad. Databastesterna hoppas över (sätt DATABASE_URL eller TEST_DATABASE_URL).\n"); + return async () => {}; + } + + const url = new URL(databaseUrl); + const name = decodeURIComponent(url.pathname.slice(1)); + if (!name.endsWith("_test")) throw new Error(`Avbryter: databasen "${name}" slutar inte på _test`); + + // Skapa databasen via en anslutning till standarddatabasen "postgres" + const admin = new URL(databaseUrl); + admin.pathname = "/postgres"; + const client = new PrismaClient({ datasources: { db: { url: admin.toString() } } }); + try { + const exists = await client.$queryRaw<{ datname: string }[]>`SELECT datname FROM pg_database WHERE datname = ${name}`; + if (exists.length === 0) await client.$executeRawUnsafe(`CREATE DATABASE "${name.replace(/"/g, "")}"`); + } finally { + await client.$disconnect(); + } + + execSync("npx prisma migrate deploy", { env: { ...process.env, DATABASE_URL: databaseUrl }, stdio: "pipe" }); + + return async () => { + await rm(dataDir, { recursive: true, force: true }); + }; +} diff --git a/tests/helpers/db.ts b/tests/helpers/db.ts new file mode 100644 index 0000000..c216537 --- /dev/null +++ b/tests/helpers/db.ts @@ -0,0 +1,63 @@ +import { randomUUID } from "node:crypto"; +import { mkdir, readdir, rm } from "node:fs/promises"; +import type { EntityKind, Prisma } from "@prisma/client"; +import { describe } from "vitest"; +import { prisma } from "@/lib/db"; +import { UPLOAD_DIR } from "@/lib/files"; +import { nextEntityCode, nextRelationCode } from "@/lib/ids"; +import { BACKUP_DIR } from "@/lib/backup"; +import { TRASH_DIR } from "@/lib/trash"; + +export { prisma }; + +/** Databastester körs bara när en testdatabas är konfigurerad (se vitest.config.ts). */ +export const hasDb = Boolean(process.env.DATABASE_URL); +export const describeDb = hasDb ? describe : describe.skip; + +/** Tömmer alla tabeller och filmapparna. Kräver att databasens namn slutar på _test. */ +export async function resetAll() { + const [{ current_database: name }] = await prisma.$queryRaw<{ current_database: string }[]>`SELECT current_database()`; + if (!name.endsWith("_test")) throw new Error(`Vägrar tömma databasen "${name}": namnet slutar inte på _test`); + + const tables = await prisma.$queryRaw<{ tablename: string }[]>`SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename <> '_prisma_migrations'`; + if (tables.length > 0) { + await prisma.$executeRawUnsafe(`TRUNCATE TABLE ${tables.map((t) => `"${t.tablename}"`).join(", ")} RESTART IDENTITY CASCADE`); + } + for (const dir of [UPLOAD_DIR, BACKUP_DIR, TRASH_DIR]) { + await rm(dir, { recursive: true, force: true }); + await mkdir(dir, { recursive: true }); + } +} + +export async function filesIn(dir: string): Promise { + try { + return (await readdir(dir)).filter((f) => f !== "thumbs").sort(); + } catch { + return []; + } +} + +export async function makeUser(name = "Tester", email: string | null = `${name.toLowerCase()}@example.com`) { + return prisma.user.create({ data: { externalId: `test:${randomUUID()}`, name, email } }); +} + +export async function makeBook(ownerId: string, title = "Testbok") { + return prisma.book.create({ data: { ownerId, title } }); +} + +export async function makeEntity( + bookId: string, + kind: EntityKind, + name: string, + extra: { data?: Prisma.InputJsonObject; imageFile?: string | null; tags?: string[]; summary?: string } = {}, +) { + return prisma.entity.create({ + data: { bookId, kind, name, code: await nextEntityCode(bookId, kind), tags: extra.tags ?? [], data: extra.data ?? {}, imageFile: extra.imageFile ?? null, summary: extra.summary ?? null }, + }); +} + +export async function makeRelation(bookId: string, fromId: string, toId: string, type = "Vänner", memberIds: string[] = []) { + return prisma.relation.create({ + data: { bookId, fromId, toId, type, code: await nextRelationCode(bookId), members: { create: memberIds.map((entityId) => ({ entityId })) } }, + }); +} diff --git a/tests/helpers/fixtures.ts b/tests/helpers/fixtures.ts new file mode 100644 index 0000000..ee63105 --- /dev/null +++ b/tests/helpers/fixtures.ts @@ -0,0 +1,38 @@ +import sharp from "sharp"; +import type { ExportData } from "@/lib/book-transfer"; + +/** En giltig minimal exportfil. Åsidosätt delar för att testa enskilda fall. */ +export function validExport(overrides: Partial = {}): ExportData { + return { + format: "bookmanager-export", + version: 1, + exportedAt: "2026-01-01T00:00:00.000Z", + includesImages: false, + book: { title: "Testbok", subtitle: null, genre: null, description: null }, + entities: [], + relations: [], + shifts: [], + maps: [], + templates: [], + ...overrides, + }; +} + +export function entityRow(id: string, kind: ExportData["entities"][number]["kind"], name: string, extra: Partial = {}): ExportData["entities"][number] { + return { id, kind, name, code: null, summary: null, tags: [], data: {}, image: null, ...extra }; +} + +/** En riktig bild (PNG, JPEG eller WebP) av önskad storlek, för tester av bildbehandling och uppladdning. */ +export async function makeImage( + width: number, + height: number, + format: "png" | "jpeg" | "webp" = "png", + options: { orientation?: number } = {}, +): Promise { + let pipeline = sharp({ create: { width, height, channels: 3, background: { r: 200, g: 60, b: 60 } } }); + if (format === "png") pipeline = pipeline.png(); + else if (format === "jpeg") pipeline = pipeline.jpeg({ quality: 40 }); + else pipeline = pipeline.webp({ quality: 40 }); + if (options.orientation) pipeline = pipeline.withMetadata({ orientation: options.orientation }); + return new Uint8Array(await pipeline.toBuffer()); +} diff --git a/tests/unit/format.test.ts b/tests/unit/format.test.ts new file mode 100644 index 0000000..84a1ad4 --- /dev/null +++ b/tests/unit/format.test.ts @@ -0,0 +1,22 @@ +import { describe, expect, it } from "vitest"; +import { formatBytes, formatDuration } from "@/lib/format"; + +describe("formatBytes", () => { + it("visar storlekar med svenskt decimaltecken", () => { + expect(formatBytes(0)).toBe("0 B"); + expect(formatBytes(1023)).toBe("1023 B"); + expect(formatBytes(1536)).toBe("1,5 KB"); + expect(formatBytes(1024 * 1024)).toBe("1,0 MB"); + expect(formatBytes(150 * 1024 * 1024)).toBe("150 MB"); + expect(formatBytes(3 * 1024 ** 3)).toBe("3,0 GB"); + }); +}); + +describe("formatDuration", () => { + it("visar dagar, timmar och minuter", () => { + expect(formatDuration(59)).toBe("0 min"); + expect(formatDuration(3600)).toBe("1 h 0 min"); + expect(formatDuration(93784)).toBe("1 d 2 h 3 min"); + expect(formatDuration(86400)).toBe("1 d 0 h 0 min"); + }); +}); diff --git a/tests/unit/history.test.ts b/tests/unit/history.test.ts new file mode 100644 index 0000000..b2e0c33 --- /dev/null +++ b/tests/unit/history.test.ts @@ -0,0 +1,59 @@ +import { describe, expect, it } from "vitest"; +import { diffSnapshots, sameSnapshot, snapshotOf, type Snapshot } from "@/lib/history"; +import type { FieldDef } from "@/lib/templates"; + +const labels = { name: "Namn", summary: "Sammanfattning", tags: "Taggar" }; +const fields: FieldDef[] = [ + { key: "age", label: "Ålder", type: "number" }, + { key: "alive", label: "Vid liv", type: "checkbox" }, +]; +const base: Snapshot = { name: "Anna", summary: null, tags: ["a"], data: { age: 30, alive: true } }; + +describe("snapshotOf", () => { + it("normaliserar saknad sammanfattning och ogiltig data", () => { + expect(snapshotOf({ name: "A", summary: null, tags: [], data: null })).toEqual({ name: "A", summary: null, tags: [], data: {} }); + expect(snapshotOf({ name: "A", summary: "x", tags: ["t"], data: [1, 2] }).data).toEqual({}); + expect(snapshotOf({ name: "A", summary: "x", tags: [], data: { k: 1 } }).data).toEqual({ k: 1 }); + }); +}); + +describe("sameSnapshot", () => { + it("är oberoende av nyckelordningen i data", () => { + const a = { ...base, data: { age: 30, alive: true } }; + const b = { ...base, data: { alive: true, age: 30 } }; + expect(sameSnapshot(a, b)).toBe(true); + }); + + it("upptäcker ändringar i namn, taggar och data", () => { + expect(sameSnapshot(base, { ...base, name: "Bo" })).toBe(false); + expect(sameSnapshot(base, { ...base, tags: ["a", "b"] })).toBe(false); + expect(sameSnapshot(base, { ...base, data: { age: 31, alive: true } })).toBe(false); + expect(sameSnapshot(base, { ...base })).toBe(true); + }); +}); + +describe("diffSnapshots", () => { + it("ger inga skillnader när inget ändrats", () => { + expect(diffSnapshots(base, { ...base }, fields, labels)).toEqual([]); + }); + + it("namnger fälten med mallens rubriker", () => { + const changes = diffSnapshots(base, { ...base, name: "Anna L", data: { age: 31, alive: true } }, fields, labels); + expect(changes).toEqual([ + { label: "Namn", before: "Anna", after: "Anna L" }, + { label: "Ålder", before: "30", after: "31" }, + ]); + }); + + it("visar taggar som lista, kryssrutor som bock och tomt som tomt", () => { + const changes = diffSnapshots(base, { ...base, tags: ["a", "b"], summary: "ny", data: { age: 30, alive: false } }, fields, labels); + expect(changes).toContainEqual({ label: "Taggar", before: "a", after: "a, b" }); + expect(changes).toContainEqual({ label: "Sammanfattning", before: "", after: "ny" }); + expect(changes).toContainEqual({ label: "Vid liv", before: "✓", after: "" }); + }); + + it("tar med värden för fält som inte längre finns i mallen", () => { + const changes = diffSnapshots({ ...base, data: { ...base.data, gammal: "x" } }, base, fields, labels); + expect(changes).toEqual([{ label: "gammal", before: "x", after: "" }]); + }); +}); diff --git a/tests/unit/ids.test.ts b/tests/unit/ids.test.ts new file mode 100644 index 0000000..6a4e104 --- /dev/null +++ b/tests/unit/ids.test.ts @@ -0,0 +1,40 @@ +import { describe, expect, it } from "vitest"; +import { ENTITY_PREFIX, mapLetter, pad } from "@/lib/ids"; +import { KINDS } from "@/lib/kinds"; + +describe("ID-prefix", () => { + it("varje posttyp med ID har ett eget prefix", () => { + const prefixes = Object.values(ENTITY_PREFIX); + expect(new Set(prefixes).size).toBe(prefixes.length); + }); + + it("alla typer utom appar och hemsidor får ID", () => { + const without = KINDS.filter((k) => !ENTITY_PREFIX[k.kind]).map((k) => k.kind); + expect(without.sort()).toEqual(["APP", "WEBSITE"]); + }); + + it("följer ID-översikten", () => { + expect(ENTITY_PREFIX.CHARACTER).toBe("KI"); + expect(ENTITY_PREFIX.COMPANY).toBe("FI"); + expect(ENTITY_PREFIX.HOME).toBe("BI"); + expect(ENTITY_PREFIX.PET).toBe("DI"); + expect(ENTITY_PREFIX.PREMISES).toBe("LI"); + expect(ENTITY_PREFIX.EDUCATION).toBe("UI"); + expect(ENTITY_PREFIX.VEHICLE).toBe("FD"); + expect(ENTITY_PREFIX.RESEARCH).toBe("RI"); + expect(ENTITY_PREFIX.REFERENCE).toBe("RD"); + expect(ENTITY_PREFIX.SKETCH).toBe("SI"); + }); + + it("kartans bokstav följer typen", () => { + expect(mapLetter("GEO")).toBe("R"); + expect(mapLetter("IMAGE")).toBe("E"); + }); + + it("siffrorna fylls ut till fyra och växer vid behov", () => { + expect(pad(1)).toBe("0001"); + expect(pad(42)).toBe("0042"); + expect(pad(9999)).toBe("9999"); + expect(pad(12345)).toBe("12345"); + }); +}); diff --git a/tests/unit/images.test.ts b/tests/unit/images.test.ts new file mode 100644 index 0000000..6996ce7 --- /dev/null +++ b/tests/unit/images.test.ts @@ -0,0 +1,79 @@ +import sharp from "sharp"; +import { describe, expect, it } from "vitest"; +import { detectImageExt, makeThumbnail, optimizeImage } from "@/lib/images"; +import { makeImage } from "../helpers/fixtures"; + +describe("detectImageExt", () => { + it("känner igen bildtyper på de första byten, inte på namnet", async () => { + expect(detectImageExt(await makeImage(4, 4, "png"))).toBe("png"); + expect(detectImageExt(await makeImage(4, 4, "jpeg"))).toBe("jpg"); + expect(detectImageExt(await makeImage(4, 4, "webp"))).toBe("webp"); + expect(detectImageExt(new TextEncoder().encode("GIF89a......"))).toBe("gif"); + }); + + it("avvisar annat än bilder", () => { + expect(detectImageExt(new TextEncoder().encode(""))).toBeNull(); + expect(detectImageExt(new TextEncoder().encode("#!/bin/sh\necho hej"))).toBeNull(); + expect(detectImageExt(new Uint8Array([]))).toBeNull(); + expect(detectImageExt(new Uint8Array([0x89, 0x50]))).toBeNull(); + }); +}); + +describe("optimizeImage", () => { + it("skalar ned stora bilder till högst 2400 px på längsta sidan", async () => { + const result = await optimizeImage(await makeImage(3600, 1800, "jpeg"), "entity"); + const meta = await sharp(result!.bytes).metadata(); + expect(result!.ext).toBe("jpg"); + expect(meta.width).toBe(2400); + expect(meta.height).toBe(1200); + }); + + it("lämnar små bilder i storlek", async () => { + const result = await optimizeImage(await makeImage(300, 200, "png"), "entity"); + const meta = await sharp(result!.bytes).metadata(); + expect([meta.width, meta.height]).toEqual([300, 200]); + expect(result!.ext).toBe("png"); + }); + + it("roterar efter EXIF och tar bort metadata", async () => { + const input = await makeImage(300, 200, "jpeg", { orientation: 6 }); + expect((await sharp(input).metadata()).orientation).toBe(6); + + const result = await optimizeImage(input, "entity"); + const meta = await sharp(result!.bytes).metadata(); + // 300x200 med rotation 90 grader blir 200x300, och orienteringsflaggan är borta + expect([meta.width, meta.height]).toEqual([200, 300]); + expect(meta.orientation).toBeUndefined(); + expect(meta.exif).toBeUndefined(); + }); + + it("kartbilder får behålla mer upplösning än porträtt", async () => { + const map = await optimizeImage(await makeImage(3000, 2000, "png"), "map"); + expect((await sharp(map!.bytes).metadata()).width).toBe(3000); + const portrait = await optimizeImage(await makeImage(3000, 2000, "png"), "entity"); + expect((await sharp(portrait!.bytes).metadata()).width).toBe(2400); + }); + + it("lämnar GIF orörd", async () => { + const gif = new TextEncoder().encode("GIF89a\x01\x00\x01\x00\x00\x00\x00;"); + const result = await optimizeImage(gif, "entity"); + expect(result?.ext).toBe("gif"); + expect(Array.from(result!.bytes)).toEqual(Array.from(gif)); + }); + + it("avvisar filer som inte är bilder eller är skadade", async () => { + expect(await optimizeImage(new TextEncoder().encode("hej"), "entity")).toBeNull(); + const png = await makeImage(50, 50, "png"); + expect(await optimizeImage(png.slice(0, 40), "entity")).toBeNull(); // avklippt bild + }); +}); + +describe("makeThumbnail", () => { + it("ger en liten WebP-bild med högst 480 px", async () => { + const thumb = await makeThumbnail(await makeImage(2000, 1000, "jpeg")); + const meta = await sharp(thumb).metadata(); + expect(meta.format).toBe("webp"); + expect(meta.width).toBe(480); + expect(meta.height).toBe(240); + }); +}); diff --git a/tests/unit/import-parse.test.ts b/tests/unit/import-parse.test.ts new file mode 100644 index 0000000..8275d18 --- /dev/null +++ b/tests/unit/import-parse.test.ts @@ -0,0 +1,138 @@ +import { strToU8, zipSync } from "fflate"; +import { describe, expect, it } from "vitest"; +import { ImportError, parseExport, readImportFile, type ImportErrorCode } from "@/lib/book-transfer"; +import { entityRow, validExport } from "../helpers/fixtures"; + +function codeOf(fn: () => unknown): ImportErrorCode | "no-error" { + try { + fn(); + return "no-error"; + } catch (error) { + if (error instanceof ImportError) return error.code; + throw error; + } +} + +const json = (data: unknown) => new TextEncoder().encode(JSON.stringify(data)); +const zip = (entries: Record) => zipSync(entries); + +describe("parseExport", () => { + it("godkänner en minimal exportfil", () => { + const parsed = parseExport(validExport()); + expect(parsed.book.title).toBe("Testbok"); + expect(parsed.entities).toEqual([]); + }); + + it("avvisar annat än en exportfil", () => { + expect(codeOf(() => parseExport(null))).toBe("not-export"); + expect(codeOf(() => parseExport([]))).toBe("not-export"); + expect(codeOf(() => parseExport({ a: 1 }))).toBe("not-export"); + expect(codeOf(() => parseExport({ ...validExport(), format: "annat" }))).toBe("not-export"); + }); + + it("avvisar okänd version", () => { + expect(codeOf(() => parseExport({ ...validExport(), version: 2 }))).toBe("version"); + }); + + it("kräver en boktitel", () => { + expect(codeOf(() => parseExport({ ...validExport(), book: { title: " " } }))).toBe("invalid"); + expect(codeOf(() => parseExport({ ...validExport(), book: undefined }))).toBe("invalid"); + }); + + it("avvisar poster med okänd typ, saknat id eller saknat namn", () => { + expect(codeOf(() => parseExport({ ...validExport(), entities: [{ id: "a", kind: "DRAGON", name: "X" }] }))).toBe("invalid"); + expect(codeOf(() => parseExport({ ...validExport(), entities: [{ kind: "CHARACTER", name: "X" }] }))).toBe("invalid"); + expect(codeOf(() => parseExport({ ...validExport(), entities: [{ id: "a", kind: "CHARACTER", name: "" }] }))).toBe("invalid"); + expect(codeOf(() => parseExport({ ...validExport(), entities: ["x"] }))).toBe("invalid"); + }); + + it("rensar och begränsar fält", () => { + const parsed = parseExport({ + ...validExport(), + entities: [{ id: "a", kind: "CHARACTER", name: ` ${"x".repeat(300)} `, tags: ["ok", "", 5, "y".repeat(100)], data: "inte ett objekt" }], + }); + expect(parsed.entities[0].name).toHaveLength(200); + expect(parsed.entities[0].tags).toEqual(["ok", "y".repeat(40)]); + expect(parsed.entities[0].data).toEqual({}); + }); + + it("avvisar för många poster", () => { + expect(codeOf(() => parseExport({ ...validExport(), entities: new Array(20001).fill(0) }))).toBe("too-large"); + }); + + it("kontrollerar pass: veckodag och tider", () => { + const shift = { personId: "a", workplaceId: null, weekday: 0, startTime: "08:00", endTime: "16:00", weeks: "ALL", label: null, scheduleCode: null }; + expect(parseExport({ ...validExport(), shifts: [shift] }).shifts).toHaveLength(1); + expect(codeOf(() => parseExport({ ...validExport(), shifts: [{ ...shift, weekday: 7 }] }))).toBe("invalid"); + expect(codeOf(() => parseExport({ ...validExport(), shifts: [{ ...shift, startTime: "25:00" }] }))).toBe("invalid"); + expect(parseExport({ ...validExport(), shifts: [{ ...shift, weeks: "knas" }] }).shifts[0].weeks).toBe("ALL"); + }); + + it("kontrollerar kartor och markeringar", () => { + const marker = { code: null, entityId: null, label: "M", note: null, color: "neon", lat: 1, lng: 2 }; + const map = { id: "m", code: null, name: "Karta", kind: "GEO", image: null, centerLat: null, centerLng: null, zoom: 3.7, markers: [marker] }; + const parsed = parseExport({ ...validExport(), maps: [map] }); + expect(parsed.maps[0].markers[0].color).toBe("blue"); // okänd färg blir standardfärg + expect(parsed.maps[0].zoom).toBe(4); + expect(codeOf(() => parseExport({ ...validExport(), maps: [{ ...map, markers: [{ ...marker, lat: "x" }] }] }))).toBe("invalid"); + expect(parseExport({ ...validExport(), maps: [{ ...map, kind: "vad som helst" }] }).maps[0].kind).toBe("GEO"); + }); + + it("hoppar över trasiga mallar utan att avvisa filen", () => { + const parsed = parseExport({ + ...validExport(), + templates: [ + { kind: "CHARACTER", fields: [{ key: "ok", label: "Ok", type: "text" }] }, + { kind: "HOME", fields: "trasig" }, + { kind: "NOPE", fields: [] }, + "skräp", + ], + }); + expect(parsed.templates).toHaveLength(1); + expect(parsed.templates[0].kind).toBe("CHARACTER"); + }); +}); + +describe("readImportFile", () => { + const valid = validExport({ entities: [entityRow("e1", "CHARACTER", "Anna")] }); + + it("läser ren JSON, även med BOM", () => { + expect(readImportFile(json(valid)).data.entities).toHaveLength(1); + const withBom = new Uint8Array([0xef, 0xbb, 0xbf, ...json(valid)]); + expect(readImportFile(withBom).data.book.title).toBe("Testbok"); + }); + + it("läser en zip med book.json och bilder", () => { + const image = new Uint8Array([1, 2, 3]); + const { data, files } = readImportFile(zip({ "book.json": json(valid), "files/a.png": image })); + expect(data.entities[0].name).toBe("Anna"); + expect(Array.from(files.keys())).toEqual(["a.png"]); + }); + + it("ignorerar allt i zip-filen utom book.json och files/", () => { + const { files } = readImportFile( + zip({ + "book.json": json(valid), + "files/ok.png": new Uint8Array([1]), + "files/undermapp/inne.png": new Uint8Array([2]), + "annat/fil.png": new Uint8Array([3]), + "hemlig.txt": new Uint8Array([4]), + }), + ); + expect(Array.from(files.keys())).toEqual(["ok.png"]); + }); + + it("hoppar över bilder som är större än gränsen", () => { + const big = new Uint8Array(17 * 1024 * 1024); // komprimeras till nästan inget men packas inte upp + const { files } = readImportFile(zip({ "book.json": json(valid), "files/stor.png": big, "files/liten.png": new Uint8Array([1]) })); + expect(Array.from(files.keys())).toEqual(["liten.png"]); + }); + + it("ger tydliga fel", () => { + expect(codeOf(() => readImportFile(new Uint8Array([])))).toBe("empty"); + expect(codeOf(() => readImportFile(new TextEncoder().encode("det här är inte JSON")))).toBe("invalid"); + expect(codeOf(() => readImportFile(new Uint8Array([0x50, 0x4b, 3, 4, 1, 2, 3])))).toBe("invalid"); // trasig zip + expect(codeOf(() => readImportFile(zip({ "annat.txt": strToU8("hej") })))).toBe("not-export"); + expect(codeOf(() => readImportFile(json({ a: 1 })))).toBe("not-export"); + }); +}); diff --git a/tests/unit/names.test.ts b/tests/unit/names.test.ts new file mode 100644 index 0000000..9938413 --- /dev/null +++ b/tests/unit/names.test.ts @@ -0,0 +1,97 @@ +import { describe, expect, it } from "vitest"; +import { normalizeName } from "@/lib/name-stats"; +import { BUILT_IN_POOLS, FEMALE_NAMES, MALE_NAMES, SURNAMES, generateName, generateNames, type NamePools } from "@/lib/names"; + +/** Förutsägbar slumpföljd: ger värdena i tur och ordning, om och om igen. */ +const sequence = (...values: number[]) => { + let i = 0; + return () => values[i++ % values.length]; +}; + +describe("inbyggda namnlistor", () => { + it("har inga dubbletter och inget namn finns i båda könen", () => { + for (const list of [FEMALE_NAMES, MALE_NAMES, SURNAMES]) expect(new Set(list).size).toBe(list.length); + expect(FEMALE_NAMES.filter((n) => MALE_NAMES.includes(n))).toEqual([]); + }); + + it("är tillräckligt stora", () => { + expect(FEMALE_NAMES.length).toBeGreaterThan(100); + expect(MALE_NAMES.length).toBeGreaterThan(100); + expect(SURNAMES.length).toBeGreaterThan(100); + }); +}); + +describe("generateName", () => { + const options = { gender: "female", middleName: false, surname: "all" } as const; + + it("väljer förnamn efter kön", () => { + for (let i = 0; i < 50; i++) { + expect(FEMALE_NAMES).toContain(generateName({ ...options, gender: "female" }).split(" ")[0]); + expect(MALE_NAMES).toContain(generateName({ ...options, gender: "male" }).split(" ")[0]); + } + }); + + it("slumpar kön när det är valfritt", () => { + const female = generateName({ ...options, gender: "any" }, BUILT_IN_POOLS, sequence(0.1, 0, 0)); + const male = generateName({ ...options, gender: "any" }, BUILT_IN_POOLS, sequence(0.9, 0, 0)); + expect(FEMALE_NAMES).toContain(female.split(" ")[0]); + expect(MALE_NAMES).toContain(male.split(" ")[0]); + }); + + it("filtrerar efternamn på -son", () => { + for (let i = 0; i < 50; i++) { + expect(generateName({ ...options, surname: "son" }).endsWith("son")).toBe(true); + expect(generateName({ ...options, surname: "other" }).endsWith("son")).toBe(false); + } + }); + + it("lägger till ett mellannamn när det önskas", () => { + const name = generateName({ ...options, middleName: true }, BUILT_IN_POOLS, sequence(0, 0.5, 0.9)); + expect(name.split(" ")).toHaveLength(3); + }); + + it("hoppar över mellannamnet om det blev samma som förnamnet", () => { + const name = generateName({ ...options, middleName: true }, BUILT_IN_POOLS, sequence(0, 0, 0)); + expect(name.split(" ")).toHaveLength(2); + }); + + it("viktar efter hur vanligt namnet är", () => { + const pools: NamePools = { female: [["Vanlig", 1000], ["Ovanlig", 1]], male: [["X", 1]], surnames: [["Andersson", 1]] }; + expect(generateName(options, pools, () => 0.5)).toBe("Vanlig Andersson"); + expect(generateName(options, pools, () => 0.9999)).toBe("Ovanlig Andersson"); + }); + + it("faller tillbaka på alla efternamn om filtret inte ger något", () => { + const pools: NamePools = { female: [["Anna", 1]], male: [["Erik", 1]], surnames: [["Lindqvist", 1]] }; + expect(generateName({ ...options, surname: "son" }, pools)).toBe("Anna Lindqvist"); + }); + + it("generateNames ger unika namn och högst begärt antal", () => { + const names = generateNames({ gender: "any", middleName: false, surname: "all" }, 20); + expect(names).toHaveLength(20); + expect(new Set(names).size).toBe(20); + const few = generateNames(options, 5, { female: [["Anna", 1]], male: [["Erik", 1]], surnames: [["A", 1]] }); + expect(few).toEqual(["Anna A"]); + }); +}); + +describe("normalizeName (statistik från SCB)", () => { + it("gör versaler till vanlig skrivning", () => { + expect(normalizeName("JACOB")).toBe("Jacob"); + expect(normalizeName("ÅSA")).toBe("Åsa"); + expect(normalizeName("ANN-MARIE")).toBe("Ann-Marie"); + }); + + it("låter vanlig skrivning vara", () => { + expect(normalizeName("Anna")).toBe("Anna"); + expect(normalizeName("Ann-Marie")).toBe("Ann-Marie"); + expect(normalizeName(" Erik ")).toBe("Erik"); + expect(normalizeName("O'Neil")).toBe("O'Neil"); + }); + + it("avvisar namn med mellanslag, siffror eller konstiga tecken", () => { + for (const bad of ["", " ", "Mc Donald", "1Adam", "Anna2", "A".repeat(31), "Anna@", ""]) { + expect(normalizeName(bad)).toBeNull(); + } + }); +}); diff --git a/tests/unit/rate-limit.test.ts b/tests/unit/rate-limit.test.ts new file mode 100644 index 0000000..533dd57 --- /dev/null +++ b/tests/unit/rate-limit.test.ts @@ -0,0 +1,63 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { clientIp, limitRequest, rateLimit, rateLimitStats } from "@/lib/rate-limit"; + +beforeEach(() => vi.useFakeTimers()); +afterEach(() => vi.useRealTimers()); + +describe("rateLimit", () => { + it("släpper igenom upp till gränsen och stoppar sedan", () => { + const key = "test-limit"; + expect(rateLimit(key, 3, 1000).ok).toBe(true); + expect(rateLimit(key, 3, 1000).ok).toBe(true); + expect(rateLimit(key, 3, 1000).ok).toBe(true); + const blocked = rateLimit(key, 3, 1000); + expect(blocked.ok).toBe(false); + expect(blocked.retryAfter).toBeGreaterThanOrEqual(1); + }); + + it("släpper igenom igen när tidsfönstret gått ut", () => { + const key = "test-window"; + for (let i = 0; i < 2; i++) rateLimit(key, 2, 1000); + expect(rateLimit(key, 2, 1000).ok).toBe(false); + vi.advanceTimersByTime(1001); + expect(rateLimit(key, 2, 1000).ok).toBe(true); + }); + + it("räknar varje nyckel för sig", () => { + rateLimit("a", 1, 1000); + expect(rateLimit("a", 1, 1000).ok).toBe(false); + expect(rateLimit("b", 1, 1000).ok).toBe(true); + }); + + it("räknar stoppade anrop", () => { + const before = rateLimitStats.blocked; + rateLimit("count", 1, 1000); + rateLimit("count", 1, 1000); + rateLimit("count", 1, 1000); + expect(rateLimitStats.blocked).toBe(before + 2); + }); +}); + +describe("clientIp och limitRequest", () => { + const request = (headers: Record) => new Request("http://localhost/x", { headers }); + + it("läser första adressen i x-forwarded-for", () => { + expect(clientIp(request({ "x-forwarded-for": "1.2.3.4, 10.0.0.1" }))).toBe("1.2.3.4"); + expect(clientIp(request({ "x-real-ip": "5.6.7.8" }))).toBe("5.6.7.8"); + expect(clientIp(request({}))).toBe("unknown"); + }); + + it("svarar 429 med Retry-After när gränsen är nådd", () => { + const req = request({ "x-forwarded-for": "9.9.9.9" }); + expect(limitRequest(req, "route", 1, 60_000)).toBeNull(); + const response = limitRequest(req, "route", 1, 60_000); + expect(response?.status).toBe(429); + expect(Number(response?.headers.get("Retry-After"))).toBeGreaterThanOrEqual(1); + }); + + it("begränsar per IP-adress", () => { + expect(limitRequest(request({ "x-forwarded-for": "1.1.1.1" }), "ip-route", 1, 60_000)).toBeNull(); + expect(limitRequest(request({ "x-forwarded-for": "2.2.2.2" }), "ip-route", 1, 60_000)).toBeNull(); + expect(limitRequest(request({ "x-forwarded-for": "1.1.1.1" }), "ip-route", 1, 60_000)).not.toBeNull(); + }); +}); diff --git a/tests/unit/security.test.ts b/tests/unit/security.test.ts new file mode 100644 index 0000000..3f711da --- /dev/null +++ b/tests/unit/security.test.ts @@ -0,0 +1,59 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; +import { contentSecurityPolicy, runtimeSecurityHeaders } from "@/lib/security"; + +afterEach(() => vi.unstubAllEnvs()); + +const directive = (csp: string, name: string) => csp.split("; ").find((d) => d.startsWith(`${name} `)) ?? ""; + +describe("Content-Security-Policy", () => { + it("släpper igenom OpenStreetMap som standard", () => { + vi.stubEnv("MAP_TILE_URL", ""); + vi.stubEnv("MAP_GEOCODER_URL", ""); + // Tomma värden (t.ex. "MAP_TILE_URL=" i .env) ska ge standard + const csp = contentSecurityPolicy(); + expect(directive(csp, "img-src")).toContain("https://tile.openstreetmap.org"); + expect(directive(csp, "connect-src")).toContain("https://nominatim.openstreetmap.org"); + expect(csp).toContain("frame-ancestors 'none'"); + expect(csp).toContain("object-src 'none'"); + expect(csp).toContain("base-uri 'self'"); + }); + + it("använder adresserna från MAP_TILE_URL och MAP_GEOCODER_URL", () => { + vi.stubEnv("MAP_TILE_URL", "https://tiles.example.com/{z}/{x}/{y}.png"); + vi.stubEnv("MAP_GEOCODER_URL", "https://geo.example.com/search"); + const csp = contentSecurityPolicy(); + expect(csp).toMatch(/img-src [^;]*https:\/\/tiles\.example\.com/); + expect(csp).toMatch(/connect-src [^;]*https:\/\/geo\.example\.com/); + expect(csp).not.toContain("openstreetmap.org"); + }); + + it("tillåter underdomäner när tilladressen har {s}", () => { + vi.stubEnv("MAP_TILE_URL", "https://{s}.tiles.example.com/{z}/{x}/{y}.png"); + expect(contentSecurityPolicy()).toContain("https://*.tiles.example.com"); + }); + + it("tillåter inte eval i produktion men gör det vid utveckling", () => { + vi.stubEnv("NODE_ENV", "production"); + expect(contentSecurityPolicy()).not.toContain("unsafe-eval"); + vi.stubEnv("NODE_ENV", "development"); + expect(contentSecurityPolicy()).toContain("unsafe-eval"); + }); + + it("ignorerar en trasig adress i stället för att krascha", () => { + vi.stubEnv("MAP_TILE_URL", "inte en adress"); + expect(() => contentSecurityPolicy()).not.toThrow(); + }); +}); + +describe("runtimeSecurityHeaders", () => { + it("sätter HSTS bara när AUTH_URL är https", () => { + vi.stubEnv("AUTH_URL", "https://bocker.example.com"); + expect(runtimeSecurityHeaders()["Strict-Transport-Security"]).toContain("max-age="); + vi.stubEnv("AUTH_URL", "http://localhost:3000"); + expect(runtimeSecurityHeaders()["Strict-Transport-Security"]).toBeUndefined(); + }); + + it("innehåller alltid en policy", () => { + expect(runtimeSecurityHeaders()["Content-Security-Policy"]).toContain("default-src 'self'"); + }); +}); diff --git a/tests/unit/templates.test.ts b/tests/unit/templates.test.ts new file mode 100644 index 0000000..8affb8c --- /dev/null +++ b/tests/unit/templates.test.ts @@ -0,0 +1,119 @@ +import { describe, expect, it } from "vitest"; +import { KINDS } from "@/lib/kinds"; +import { FIELD_TYPES, formatFieldValue, getDefaultTemplate, getPresets, validateFields } from "@/lib/templates"; + +const ALL_KINDS = [...KINDS.map((k) => k.kind), "RELATION" as const]; + +describe("standardmallar", () => { + for (const locale of ["sv", "en"] as const) { + for (const kind of ALL_KINDS) { + it(`${kind} (${locale}) har giltiga fält med unika nycklar`, () => { + const fields = getDefaultTemplate(kind, locale); + expect(fields.length).toBeGreaterThan(0); + // Mallen ska klara samma kontroll som en sparad mall + expect(validateFields(fields)).toEqual(fields); + expect(new Set(fields.map((f) => f.key)).size).toBe(fields.length); + }); + } + } + + it("val-fält har alternativ och kopplingsfält pekar på en känd typ", () => { + for (const kind of ALL_KINDS) { + for (const field of getDefaultTemplate(kind, "sv")) { + if (field.type === "select") expect(field.options?.length).toBeGreaterThan(0); + if (field.refKind) expect(KINDS.map((k) => k.kind)).toContain(field.refKind); + } + } + }); + + it("svenska och engelska mallar har samma nycklar i samma ordning", () => { + for (const kind of ALL_KINDS) { + expect(getDefaultTemplate(kind, "en").map((f) => f.key)).toEqual(getDefaultTemplate(kind, "sv").map((f) => f.key)); + } + }); + + it("kopplingar i standardmallarna är fältet Lokal i företag och utbildning", () => { + const company = getDefaultTemplate("COMPANY", "sv").find((f) => f.key === "premises"); + expect(company).toMatchObject({ type: "reference", refKind: "PREMISES" }); + expect(getDefaultTemplate("EDUCATION", "sv").find((f) => f.key === "premises")).toMatchObject({ type: "reference", refKind: "PREMISES" }); + }); + + it("den korta karaktärsmallen är en delmängd av den fulla", () => { + const full = getDefaultTemplate("CHARACTER", "sv").map((f) => f.key); + const [preset] = getPresets("CHARACTER", "sv"); + expect(preset.id).toBe("short"); + expect(preset.fields.length).toBeLessThan(full.length); + for (const field of preset.fields) expect(full).toContain(field.key); + expect(getPresets("HOME", "sv")).toEqual([]); + }); +}); + +describe("validateFields", () => { + const ok = { key: "age", label: "Ålder", type: "number" }; + + it("godkänner en giltig mall och rensar mellanslag", () => { + expect(validateFields([{ key: " age ", label: " Ålder ", type: "number", section: " Basics " }])).toEqual([ + { key: "age", label: "Ålder", type: "number", section: "Basics" }, + ]); + }); + + it("kräver en lista", () => { + expect(() => validateFields({})).toThrow(); + expect(() => validateFields("x")).toThrow(); + }); + + it("avvisar ogiltiga nycklar", () => { + for (const key of ["", "1abc", "a-b", "a b", "å", "x".repeat(50)]) { + expect(() => validateFields([{ ...ok, key }])).toThrow(); + } + }); + + it("avvisar dubbletter av nyckel", () => { + expect(() => validateFields([ok, { ...ok, label: "Annat" }])).toThrow(/duplicate/); + }); + + it("avvisar saknad rubrik och okänd typ", () => { + expect(() => validateFields([{ ...ok, label: " " }])).toThrow(); + expect(() => validateFields([{ ...ok, type: "magic" }])).toThrow(); + }); + + it("godkänner alla fälttyper", () => { + for (const type of FIELD_TYPES) expect(() => validateFields([{ key: "f", label: "F", type }])).not.toThrow(); + }); + + it("val-fält får rensade alternativ och andra typer får inga", () => { + const [select] = validateFields([{ key: "s", label: "S", type: "select", options: [" A ", "", "B"] }]); + expect(select.options).toEqual(["A", "B"]); + const [text] = validateFields([{ key: "t", label: "T", type: "text", options: ["A"] }]); + expect(text.options).toBeUndefined(); + }); + + it("kopplingsfält godkänner känd typ och avvisar okänd", () => { + expect(validateFields([{ key: "p", label: "P", type: "reference", refKind: "PREMISES" }])[0].refKind).toBe("PREMISES"); + expect(validateFields([{ key: "p", label: "P", type: "reference" }])[0].refKind).toBeUndefined(); + expect(() => validateFields([{ key: "p", label: "P", type: "reference", refKind: "NOPE" }])).toThrow(); + }); + + it("begränsar antal fält och rubrikens längd", () => { + const many = Array.from({ length: 101 }, (_, i) => ({ key: `f${i}`, label: "F", type: "text" })); + expect(() => validateFields(many)).toThrow(); + expect(validateFields([{ key: "f", label: "x".repeat(500), type: "text" }])[0].label.length).toBe(160); + }); +}); + +describe("formatFieldValue", () => { + it("visar värden som text", () => { + const text = { key: "t", label: "T", type: "text" as const }; + expect(formatFieldValue(text, "hej")).toBe("hej"); + expect(formatFieldValue({ ...text, type: "number" }, 0)).toBe("0"); + expect(formatFieldValue(text, null)).toBe(""); + expect(formatFieldValue(text, undefined)).toBe(""); + expect(formatFieldValue(text, "")).toBe(""); + }); + + it("visar kryssrutor som bock eller tomt, och kopplingar som tomt", () => { + expect(formatFieldValue({ key: "c", label: "C", type: "checkbox" }, true)).toBe("✓"); + expect(formatFieldValue({ key: "c", label: "C", type: "checkbox" }, false)).toBe(""); + expect(formatFieldValue({ key: "r", label: "R", type: "reference" }, "abc")).toBe(""); + }); +}); diff --git a/tsconfig.json b/tsconfig.json index 6eb7e67..1cf875b 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -26,7 +26,8 @@ "@/*": [ "./src/*" ] - } + }, + "allowImportingTsExtensions": true }, "include": [ "next-env.d.ts", diff --git a/vitest.config.mts b/vitest.config.mts new file mode 100644 index 0000000..4b34ff6 --- /dev/null +++ b/vitest.config.mts @@ -0,0 +1,28 @@ +import os from "node:os"; +import path from "node:path"; +import { defineConfig } from "vitest/config"; +import { testDatabaseUrl } from "./tests/db-url.mts"; + +const databaseUrl = testDatabaseUrl(); +const dataDir = path.join(os.tmpdir(), "bookmanager-test-data"); + +export default defineConfig({ + resolve: { alias: { "@": path.resolve(import.meta.dirname, "src") } }, + test: { + environment: "node", + include: ["tests/**/*.test.ts"], + globalSetup: ["tests/global-setup.ts"], + // Alla filer delar en databas, så de körs efter varandra + fileParallelism: false, + testTimeout: 30_000, + env: { + // Tom sträng betyder att databastesterna hoppas över + DATABASE_URL: databaseUrl ?? "", + UPLOAD_DIR: path.join(dataDir, "uploads"), + BACKUP_DIR: path.join(dataDir, "backups"), + TRASH_DIR: path.join(dataDir, "trash"), + LOG_LEVEL: "error", + ADMIN_EMAILS: "", + }, + }, +});