backend-manager 5.9.4 → 5.9.6

package/test/routes/admin/notification.js

@@ -1,198 +0,0 @@
-/**
- * Test: POST /admin/notification
- * Tests the admin send notification (FCM) endpoint
- * Requires admin authentication
- */
-const { TEST_DATA } = require('../../../src/test/test-accounts.js');
-
-module.exports = {
-  description: 'Admin send notification (FCM)',
-  type: 'group',
-  tests: [
-    // Test 1: Admin can call send-notification with no subscribers
-    {
-      name: 'admin-succeeds-empty-collection',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'BEM Test Notification',
-            body: 'Testing from BEM test suite',
-            clickAction: 'https://example.com/test',
-          },
-        });
-
-        assert.isSuccess(response, 'Send notification should succeed for admin');
-        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
-        assert.hasProperty(response, 'data.deleted', 'Response should have deleted count');
-      },
-    },
-
-    // Test 2: Notification with owner filter
-    {
-      name: 'with-owner-filter',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'Filtered Notification',
-            body: 'Testing owner filter',
-          },
-          filters: {
-            owner: TEST_DATA.filterUid,
-            limit: 10,
-          },
-        });
-
-        assert.isSuccess(response, 'Send notification with filters should succeed');
-        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
-      },
-    },
-
-    // Test 3: Notification with tags filter
-    {
-      name: 'with-tags-filter',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'Tagged Notification',
-            body: 'Testing tags filter',
-          },
-          filters: {
-            tags: ['test-tag', 'another-tag'],
-          },
-        });
-
-        assert.isSuccess(response, 'Send notification with tags filter should succeed');
-      },
-    },
-
-    // Test 4: Notification with limit filter
-    {
-      name: 'with-limit-filter',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'Limited Notification',
-            body: 'Testing limit filter',
-          },
-          filters: {
-            limit: 5,
-          },
-        });
-
-        assert.isSuccess(response, 'Send notification with limit should succeed');
-        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
-      },
-    },
-
-    // Test 5: Default notification values applied when notification is omitted
-    {
-      name: 'default-values-applied',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        // Omit notification entirely to test schema defaults are applied
-        const response = await http.post('backend-manager/admin/notification', {
-          filters: {
-            limit: 1,
-          },
-        });
-
-        assert.isSuccess(response, 'Send notification with defaults should succeed');
-      },
-    },
-
-    // Test 6: Send to real FCM token (requires TEST_FCM_TOKEN env var)
-    {
-      name: 'send-to-real-token',
-      auth: 'admin',
-      timeout: 30000,
-      skip: !process.env.TEST_FCM_TOKEN ? 'TEST_FCM_TOKEN env var not set' : false,
-
-      async run({ http, assert, config }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'BEM Test Notification',
-            body: `Test sent at ${new Date().toISOString()}`,
-            clickAction: `https://${config.domain}/?test-notification=true`,
-          },
-          filters: {
-            token: process.env.TEST_FCM_TOKEN,
-          },
-        });
-
-        assert.isSuccess(response, 'Send notification to real token should succeed');
-        assert.hasProperty(response, 'data.sent', 'Response should have sent count');
-      },
-    },
-
-    // Test 7: Send to fake token (API succeeds, FCM fails silently)
-    {
-      name: 'fake-token-api-succeeds',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'Fake Token Test',
-            body: 'Testing with invalid token',
-          },
-          filters: {
-            token: 'fake-invalid-token-for-testing',
-          },
-        });
-
-        assert.isSuccess(response, 'Send notification to fake token should succeed API-wise');
-      },
-    },
-
-    // Test 8: Unauthenticated request fails
-    {
-      name: 'unauthenticated-rejected',
-      auth: 'none',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'Test Notification',
-            body: 'This is a test',
-          },
-        });
-
-        assert.isError(response, 401, 'Send notification should fail without authentication');
-      },
-    },
-
-    // Test 9: Non-admin user fails
-    {
-      name: 'non-admin-rejected',
-      auth: 'basic',
-      timeout: 15000,
-
-      async run({ http, assert }) {
-        const response = await http.post('backend-manager/admin/notification', {
-          notification: {
-            title: 'Test Notification',
-            body: 'This is a test',
-          },
-        });
-
-        assert.isError(response, 403, 'Send notification should fail for non-admin user');
-      },
-    },
-  ],
-};

package/test/routes/admin/post-resize-image.js

@@ -1,184 +0,0 @@
-/**
- * Test: routes/admin/post/post.resizeImage
- * Unit tests for the in-place image resize used by the admin/post route.
- *
- * Run: npx mgr test routes/admin/post-resize-image
- *
- * Contract:
- *   - Images with both dimensions <= IMAGE_MAX_DIMENSION pass through untouched.
- *   - Images with either dimension > IMAGE_MAX_DIMENSION are resized in place,
- *     preserving aspect ratio, with the long edge clamped to IMAGE_MAX_DIMENSION.
- *   - Resize re-encodes as JPEG at IMAGE_JPEG_QUALITY (lossy is expected).
- *   - The file at the original path is overwritten with the resized bytes.
- */
-const os = require('os');
-const path = require('path');
-const jetpack = require('fs-jetpack');
-const sharp = require('sharp');
-
-const post = require('../../../src/manager/routes/admin/post/post');
-
-const { resizeImage, IMAGE_MAX_DIMENSION, IMAGE_JPEG_QUALITY } = post;
-
-// Generate a synthetic JPEG of the given dimensions and write it to a tmp path.
-// Returns the absolute path on disk.
-async function makeJpeg(width, height) {
-  const filepath = path.join(os.tmpdir(), `bem-test-resize-${Date.now()}-${width}x${height}.jpg`);
-  const buffer = await sharp({
-    create: {
-      width: width,
-      height: height,
-      channels: 3,
-      background: { r: 128, g: 128, b: 128 },
-    },
-  })
-    .jpeg({ quality: 90 })
-    .toBuffer();
-
-  jetpack.write(filepath, buffer);
-  return filepath;
-}
-
-// Minimal assistant stub — resizeImage only uses Manager.require + log.
-function makeAssistant() {
-  return {
-    log: () => {},
-    Manager: {
-      require: (mod) => require(mod),
-    },
-  };
-}
-
-module.exports = {
-  description: 'routes/admin/post/post.resizeImage',
-  type: 'group',
-
-  tests: [
-    // ─── Constants exposed ───
-
-    {
-      name: 'exports-constants',
-      async run({ assert }) {
-        assert.equal(IMAGE_MAX_DIMENSION, 2048, 'IMAGE_MAX_DIMENSION should be 2048');
-        assert.equal(IMAGE_JPEG_QUALITY, 80, 'IMAGE_JPEG_QUALITY should be 80');
-        assert.isType(resizeImage, 'function', 'resizeImage should be exported as a function');
-      },
-    },
-
-    // ─── Pass-through: image already within bounds ───
-
-    {
-      name: 'small-image-passes-through-untouched',
-      async run({ assert }) {
-        const filepath = await makeJpeg(800, 600);
-        const sizeBefore = jetpack.inspect(filepath).size;
-
-        const result = await resizeImage(makeAssistant(), filepath);
-
-        assert.equal(result.resized, false, 'Small image should not be resized');
-        assert.equal(result.width, 800, 'Width should be reported as-is');
-        assert.equal(result.height, 600, 'Height should be reported as-is');
-
-        const sizeAfter = jetpack.inspect(filepath).size;
-        assert.equal(sizeAfter, sizeBefore, 'File on disk should be byte-identical (no re-encode)');
-
-        jetpack.remove(filepath);
-      },
-    },
-
-    {
-      name: 'image-exactly-at-max-passes-through',
-      async run({ assert }) {
-        const filepath = await makeJpeg(IMAGE_MAX_DIMENSION, 1000);
-
-        const result = await resizeImage(makeAssistant(), filepath);
-
-        assert.equal(result.resized, false, 'Image exactly at the limit should not be resized');
-        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Width unchanged');
-
-        jetpack.remove(filepath);
-      },
-    },
-
-    // ─── Resize: landscape (width > height) ───
-
-    {
-      name: 'landscape-oversized-is-resized-to-max-width',
-      async run({ assert }) {
-        // 8000x4000 landscape → long edge is width → clamp to 2048, height scales to 1024
-        const filepath = await makeJpeg(8000, 4000);
-
-        const result = await resizeImage(makeAssistant(), filepath);
-
-        assert.equal(result.resized, true, 'Oversized landscape should be resized');
-        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Width clamped to IMAGE_MAX_DIMENSION');
-        assert.equal(result.height, IMAGE_MAX_DIMENSION / 2, 'Height scaled proportionally');
-
-        const meta = await sharp(filepath).metadata();
-        assert.equal(meta.width, IMAGE_MAX_DIMENSION, 'On-disk width matches reported width');
-        assert.equal(meta.height, IMAGE_MAX_DIMENSION / 2, 'On-disk height matches reported height');
-        assert.equal(meta.format, 'jpeg', 'On-disk format is JPEG');
-
-        jetpack.remove(filepath);
-      },
-    },
-
-    // ─── Resize: portrait (height > width) ───
-
-    {
-      name: 'portrait-oversized-is-resized-to-max-height',
-      async run({ assert }) {
-        // 4000x8000 portrait → long edge is height → clamp to 2048, width scales to 1024
-        const filepath = await makeJpeg(4000, 8000);
-
-        const result = await resizeImage(makeAssistant(), filepath);
-
-        assert.equal(result.resized, true, 'Oversized portrait should be resized');
-        assert.equal(result.width, IMAGE_MAX_DIMENSION / 2, 'Width scaled proportionally');
-        assert.equal(result.height, IMAGE_MAX_DIMENSION, 'Height clamped to IMAGE_MAX_DIMENSION');
-
-        jetpack.remove(filepath);
-      },
-    },
-
-    // ─── Resize: huge image (the bug we are guarding against) ───
-
-    {
-      name: 'huge-image-is-resized-down',
-      async run({ assert }) {
-        // 16384x10576 — the actual size from post-1779087609.
-        const filepath = await makeJpeg(16384, 10576);
-        const sizeBefore = jetpack.inspect(filepath).size;
-
-        const result = await resizeImage(makeAssistant(), filepath);
-
-        assert.equal(result.resized, true, 'Huge image should be resized');
-        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Long edge clamped to IMAGE_MAX_DIMENSION');
-        // 16384:10576 ratio → height = 2048 * (10576/16384) = 1322
-        assert.inRange(result.height, 1321, 1323, 'Height scaled proportionally (within rounding)');
-
-        const sizeAfter = jetpack.inspect(filepath).size;
-        assert.ok(sizeAfter < sizeBefore, 'Resized file on disk should be smaller than original');
-
-        jetpack.remove(filepath);
-      },
-    },
-
-    // ─── Square images ───
-
-    {
-      name: 'square-oversized-is-resized-to-square',
-      async run({ assert }) {
-        const filepath = await makeJpeg(8000, 8000);
-
-        const result = await resizeImage(makeAssistant(), filepath);
-
-        assert.equal(result.resized, true, 'Oversized square should be resized');
-        assert.equal(result.width, IMAGE_MAX_DIMENSION, 'Width clamped');
-        assert.equal(result.height, IMAGE_MAX_DIMENSION, 'Height clamped');
-
-        jetpack.remove(filepath);
-      },
-    },
-  ],
-};