backend-manager 5.9.7 → 5.9.9

package/test/routes/user/feedback.js

@@ -0,0 +1,104 @@
+/**
+ * Test: POST /user/feedback
+ * Tests the user submit feedback endpoint
+ * Requires authentication, saves feedback to Firestore
+ * Note: Makes external call to ITW getApp endpoint
+ */
+module.exports = {
+  description: 'User submit feedback',
+  type: 'group',
+  tests: [
+    // Test 1: Authenticated user can submit feedback
+    {
+      name: 'authenticated-user-succeeds',
+      auth: 'basic',
+      timeout: 30000, // Longer timeout due to external API call
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/feedback', {
+          rating: 'like',
+          like: 'Great app! Works well.',
+          dislike: '',
+        });
+
+        assert.isSuccess(response, 'Submit feedback should succeed for authenticated user');
+        assert.hasProperty(response, 'data.review', 'Response should contain review decision');
+        assert.hasProperty(response, 'data.originalRequest', 'Response should contain original request');
+      },
+    },
+
+    // Test 2: Feedback with love rating
+    {
+      name: 'love-rating-succeeds',
+      auth: 'basic',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/feedback', {
+          rating: 'love',
+          like: 'Absolutely love this app! Best thing ever! Highly recommend!',
+          dislike: '',
+        });
+
+        assert.isSuccess(response, 'Submit feedback with love rating should succeed');
+        assert.hasProperty(response, 'data.review.promptReview', 'Response should have promptReview flag');
+        assert.ok(
+          typeof response.data.review.promptReview === 'boolean',
+          'promptReview should be a boolean'
+        );
+      },
+    },
+
+    // Test 3: Feedback with dislike
+    {
+      name: 'dislike-feedback-succeeds',
+      auth: 'basic',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/feedback', {
+          rating: 'dislike',
+          like: '',
+          dislike: 'Could use some improvements in the UI',
+        });
+
+        assert.isSuccess(response, 'Submit negative feedback should succeed');
+        assert.hasProperty(response, 'data.review', 'Response should contain review decision');
+      },
+    },
+
+    // Test 4: Premium user can submit feedback
+    {
+      name: 'premium-user-succeeds',
+      auth: 'premium-active',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/feedback', {
+          rating: 'like',
+          like: 'Premium features are great!',
+          dislike: '',
+        });
+
+        assert.isSuccess(response, 'Submit feedback should succeed for premium user');
+      },
+    },
+
+    // Test 5: Unauthenticated request fails
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/feedback', {
+          rating: 'like',
+          like: 'Test',
+          dislike: '',
+        });
+
+        assert.isError(response, 401, 'Submit feedback should fail without authentication');
+      },
+    },
+  ],
+};

package/test/routes/user/sessions.js

@@ -0,0 +1,199 @@
+/**
+ * Test: GET /user/sessions and DELETE /user/sessions
+ * Tests the user sessions endpoints
+ * GET returns sessions for authenticated users from Realtime Database
+ * DELETE signs out all sessions (revokes refresh tokens and clears session data)
+ */
+module.exports = {
+  description: 'User sessions (get and sign-out)',
+  type: 'group',
+  tests: [
+    // --- GET /user/sessions tests ---
+
+    // Test 1: Authenticated user can get sessions
+    {
+      name: 'get-authenticated-user-succeeds',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.get('backend-manager/user/sessions', {});
+
+        assert.isSuccess(response, 'Get active sessions should succeed for authenticated user');
+        assert.ok(
+          typeof response.data === 'object',
+          'Response data should be an object'
+        );
+      },
+    },
+
+    // Test 2: Default session id is 'app'
+    {
+      name: 'get-default-session-is-app',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        // With no id specified, should query sessions/app
+        const response = await http.get('backend-manager/user/sessions', {});
+
+        assert.isSuccess(response, 'Get active sessions should succeed');
+        // Response is an object (may be empty if no sessions)
+        assert.ok(
+          response.data !== undefined,
+          'Response should have data'
+        );
+      },
+    },
+
+    // Test 3: Custom session id
+    {
+      name: 'get-custom-session-id',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.get('backend-manager/user/sessions', {
+          id: 'custom-session-type',
+        });
+
+        assert.isSuccess(response, 'Get active sessions with custom id should succeed');
+        assert.ok(
+          typeof response.data === 'object',
+          'Response data should be an object'
+        );
+      },
+    },
+
+    // Test 4: Empty sessions returns empty object
+    {
+      name: 'get-no-sessions-returns-empty',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        // Query a session type that definitely doesn't exist
+        const response = await http.get('backend-manager/user/sessions', {
+          id: 'nonexistent-session-type-12345',
+        });
+
+        assert.isSuccess(response, 'Get sessions for empty type should succeed');
+        assert.ok(
+          Object.keys(response.data).length === 0,
+          'Empty session type should return empty object'
+        );
+      },
+    },
+
+    // Test 5: Admin can get sessions
+    {
+      name: 'get-admin-succeeds',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.get('backend-manager/user/sessions', {});
+
+        assert.isSuccess(response, 'Get active sessions should succeed for admin');
+      },
+    },
+
+    // Test 6: Unauthenticated GET request fails
+    {
+      name: 'get-unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.get('backend-manager/user/sessions', {});
+
+        assert.isError(response, 401, 'Get active sessions should fail without authentication');
+      },
+    },
+
+    // --- DELETE /user/sessions tests ---
+
+    // Test 7: Authenticated user can sign out all sessions
+    {
+      name: 'delete-authenticated-user-succeeds',
+      auth: 'basic',
+      timeout: 30000, // Longer timeout due to session cleanup
+
+      async run({ http, assert }) {
+        const response = await http.delete('backend-manager/user/sessions', {});
+
+        assert.isSuccess(response, 'Sign out all sessions should succeed for authenticated user');
+        assert.hasProperty(response, 'data.sessions', 'Response should contain sessions count');
+        assert.hasProperty(response, 'data.message', 'Response should contain message');
+        assert.ok(
+          typeof response.data.sessions === 'number',
+          'sessions should be a number'
+        );
+        assert.ok(
+          response.data.sessions >= 0,
+          'sessions count should be non-negative'
+        );
+      },
+    },
+
+    // Test 8: Custom session id for delete
+    {
+      name: 'delete-custom-session-id',
+      auth: 'basic',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.delete('backend-manager/user/sessions', {
+          id: 'custom-session-type',
+        });
+
+        assert.isSuccess(response, 'Sign out with custom session id should succeed');
+        assert.hasProperty(response, 'data.sessions', 'Response should contain sessions count');
+      },
+    },
+
+    // Test 9: Premium user can sign out all sessions
+    // Note: backendManagerKey admin doesn't have auth.uid, so we test with premium user instead
+    {
+      name: 'delete-premium-user-succeeds',
+      auth: 'premium-active',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.delete('backend-manager/user/sessions', {});
+
+        assert.isSuccess(response, 'Sign out all sessions should succeed for premium user');
+        assert.hasProperty(response, 'data.sessions', 'Response should contain sessions count');
+      },
+    },
+
+    // Test 10: Multiple calls are idempotent
+    {
+      name: 'delete-idempotent-operation',
+      auth: 'basic',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        // Call twice in a row - both should succeed
+        const response1 = await http.delete('backend-manager/user/sessions', {});
+        const response2 = await http.delete('backend-manager/user/sessions', {});
+
+        assert.isSuccess(response1, 'First sign out should succeed');
+        assert.isSuccess(response2, 'Second sign out should succeed (idempotent)');
+      },
+    },
+
+    // Test 11: Unauthenticated DELETE request fails
+    {
+      name: 'delete-unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.delete('backend-manager/user/sessions', {});
+
+        assert.isError(response, 401, 'Sign out all sessions should fail without authentication');
+      },
+    },
+  ],
+};

package/test/routes/user/settings-validate.js

@@ -0,0 +1,82 @@
+/**
+ * Test: POST /user/settings/validate
+ * Tests the user validate settings endpoint
+ * Requires authentication and validates settings against schema
+ *
+ * SKIPPED: Requires project-specific defaults.js file which BEM test environment doesn't have
+ */
+module.exports = {
+  description: 'User validate settings',
+  skip: 'Requires project-specific defaults.js file',
+  type: 'group',
+  tests: [
+    // Test 1: Authenticated user can validate settings
+    {
+      name: 'authenticated-user-succeeds',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/settings/validate', {
+          existingSettings: {},
+          newSettings: {},
+        });
+
+        assert.isSuccess(response, 'Validate settings should succeed for authenticated user');
+      },
+    },
+
+    // Test 2: With existing settings
+    {
+      name: 'with-existing-settings',
+      auth: 'basic',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/settings/validate', {
+          existingSettings: {
+            theme: 'dark',
+            notifications: true,
+          },
+          newSettings: {
+            theme: 'light',
+          },
+        });
+
+        assert.isSuccess(response, 'Validate settings with data should succeed');
+      },
+    },
+
+    // Test 3: Premium user can validate settings
+    {
+      name: 'premium-user-succeeds',
+      auth: 'premium-active',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/settings/validate', {
+          existingSettings: {},
+          newSettings: {},
+        });
+
+        assert.isSuccess(response, 'Validate settings should succeed for premium user');
+      },
+    },
+
+    // Test 4: Unauthenticated request fails
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('backend-manager/user/settings/validate', {
+          existingSettings: {},
+          newSettings: {},
+        });
+
+        assert.isError(response, 401, 'Validate settings should fail without authentication');
+      },
+    },
+  ],
+};