Clean up old errors

src/lib/app.ts

@@ -28,7 +28,7 @@ import { Knex } from 'knex';
 import maintenanceMiddleware from './middleware/maintenance-middleware';
 import { unless } from './middleware/unless-middleware';
 import { catchAllErrorHandler } from './middleware/catch-all-error-handler';
-import { UnleashError } from './error/api-error';
+import NotFoundError from './error/notfound-error';
 
 export default async function getApp(
     config: IUnleashConfig,
@@ -186,10 +186,9 @@ export default async function getApp(
 
     // handle all API 404s
     app.use(`${baseUriPath}/api`, (req, res) => {
-        const error = new UnleashError({
-            name: 'NotFoundError',
-            message: `The path you were looking for (${baseUriPath}/api${req.path}) is not available.`,
-        });
+        const error = new NotFoundError(
+            `The path you were looking for (${baseUriPath}/api${req.path}) is not available.`,
+        );
         res.status(error.statusCode).send(error);
         return;
     });

src/lib/error/api-error.test.ts

@@ -1,23 +1,29 @@
 import owasp from 'owasp-password-strength-test';
 import { ErrorObject } from 'ajv';
+import AuthenticationRequired from '../types/authentication-required';
 import {
     ApiErrorSchema,
     fromLegacyError,
-    fromOpenApiValidationError,
-    fromOpenApiValidationErrors,
     UnleashApiErrorNameWithoutExtraData,
     UnleashApiErrorTypes,
-    UnleashError,
 } from './api-error';
-import BadDataError from './bad-data-error';
+import BadDataError, {
+    fromOpenApiValidationError,
+    fromOpenApiValidationErrors,
+} from './bad-data-error';
+import NoAccessError from './no-access-error';
 import OwaspValidationError from './owasp-validation-error';
+import IncompatibleProjectError from './incompatible-project-error';
+import PasswordUndefinedError from './password-undefined';
+import ProjectWithoutOwnerError from './project-without-owner-error';
+import NotFoundError from './notfound-error';
 
 describe('v5 deprecation: backwards compatibility', () => {
     it.each(UnleashApiErrorTypes)(
         'Adds details to error type: "%s"',
         (name: UnleashApiErrorNameWithoutExtraData) => {
             const message = `Error type: ${name}`;
-            const error = new UnleashError({ name, message }).toJSON();
+            const error = new NotFoundError(message).toJSON();
 
             expect(error.message).toBe(message);
             expect(error.details).toStrictEqual([
@@ -35,7 +41,6 @@ describe('Standard/legacy error conversion', () => {
         const message = `: message!`;
         const result = fromLegacyError(new BadDataError(message)).toJSON();
 
-        expect(result.message.includes('`details`'));
         expect(result.details).toStrictEqual([
             {
                 message,
@@ -211,7 +216,7 @@ describe('OpenAPI error conversion', () => {
         const serializedUnleashError: ApiErrorSchema =
             fromOpenApiValidationErrors({ newprop: 7 }, errors).toJSON();
 
-        expect(serializedUnleashError.name).toBe('ValidationError');
+        expect(serializedUnleashError.name).toBe('BadDataError');
         expect(serializedUnleashError.message).toContain('`details`');
         expect(
             serializedUnleashError.details!![0].description.includes('newprop'),
@@ -333,3 +338,79 @@ describe('Error serialization special cases', () => {
         expect(json.details!![0].validationErrors).toBe(results.errors);
     });
 });
+
+describe('Error serialization special cases', () => {
+    it('AuthenticationRequired: adds `path` and `type`', () => {
+        const type = 'password';
+        const path = '/api/login';
+        const error = new AuthenticationRequired({
+            type,
+            path,
+            message: 'this is a message',
+        });
+
+        const json = error.toJSON();
+
+        expect(json.path).toBe(path);
+        expect(json.type).toBe(type);
+    });
+
+    it('NoAccessError: adds `permission`', () => {
+        const permission = 'x';
+        const error = new NoAccessError(permission);
+        const json = error.toJSON();
+
+        expect(json.permission).toBe(permission);
+    });
+
+    it('BadDataError: adds `details` with error details', () => {
+        const description = 'You did **this** wrong';
+        const error = new BadDataError(description).toJSON();
+
+        expect(error.details![0].message).toBe(description);
+        expect(error.details![0].description).toBe(description);
+    });
+
+    it('OwaspValidationErrors: adds `validationErrors` to `details`', () => {
+        const results = owasp.test('123');
+        const error = new OwaspValidationError(results);
+        const json = error.toJSON();
+
+        expect(json.message).toBe(results.errors[0]);
+        expect(json.details![0].message).toBe(results.errors[0]);
+        expect(json.details![0].validationErrors).toBe(results.errors);
+    });
+
+    it('IncompatibleProjectError: adds `validationErrors: []` to the `details` list', () => {
+        const targetProject = 'x';
+        const error = new IncompatibleProjectError(targetProject);
+        const json = error.toJSON();
+
+        expect(json.details![0].validationErrors).toStrictEqual([]);
+        expect(json.details![0].message).toMatch(/\bx\b/);
+    });
+
+    it('PasswordUndefinedError: adds `validationErrors: []` to the `details` list', () => {
+        const error = new PasswordUndefinedError();
+        const json = error.toJSON();
+
+        expect(json.details![0].validationErrors).toStrictEqual([]);
+        expect(json.details![0].message).toMatch(json.message);
+    });
+
+    it('ProjectWithoutOwnerError: adds `validationErrors: []` to the `details` list', () => {
+        const error = new ProjectWithoutOwnerError();
+        const json = error.toJSON();
+
+        expect(json.details![0].validationErrors).toStrictEqual([]);
+        expect(json.details![0].message).toMatch(json.message);
+    });
+});
+
+describe('Stack traces', () => {
+    it('captures stack traces regardless of whether `Error.captureStackTrace` is called explicitly or not', () => {
+        const e = new PasswordUndefinedError();
+
+        expect(e.stack).toBeTruthy();
+    });
+});