feat: Handle resetting password for inactive user

This now throws an PasswordCannotBeResetError. 
This commit also adds tests for the error dispatching.

Author: Francesco Novy

addon/errors/cognito.ts

@@ -10,13 +10,20 @@ export class CognitoError extends Error {
   name: string;
   _error: AmazonCognitoIdentityJsError;
 
-  constructor(error: string | AmazonCognitoIdentityJsError, message?: string) {
+  constructor(
+    error: string | AmazonCognitoIdentityJsError | null,
+    message?: string
+  ) {
     if (typeof error === 'string') {
       message = error;
       error = { message, name: 'CognitoError' };
     }
 
-    let humanMessage = message || error.message;
+    if (!error || typeof error !== 'object') {
+      error = { message: 'An error has occurred.', name: 'CognitoError' };
+    }
+
+    let humanMessage = message || error.message || 'An error has occurred.';
 
     super(humanMessage);
 
@@ -27,6 +34,7 @@ export class CognitoError extends Error {
   }
 }
 
+// Note: This error is never thrown by dispatchError, but only manually in cognito._authenticate()
 export class NewPasswordRequiredError extends CognitoError {
   userAttributes: Object;
   requiredAttributes: Object;
@@ -82,6 +90,16 @@ export class InvalidPasswordError extends CognitoError {
   }
 }
 
+export class PasswordCannotBeResetError extends CognitoError {
+  constructor(error: AmazonCognitoIdentityJsError) {
+    super(
+      error,
+      'The user you are trying to reset the password for is not active.'
+    );
+    this.name = 'PasswordCannotBeResetError';
+  }
+}
+
 export function dispatchError(error: AmazonCognitoIdentityJsError) {
   let errorMap = {
     PasswordResetRequiredException: PasswordResetRequiredError,
@@ -94,7 +112,7 @@ export function dispatchError(error: AmazonCognitoIdentityJsError) {
   };
 
   if (!error || typeof error !== 'object') {
-    return error;
+    return new CognitoError(error);
   }
 
   // @ts-ignore
@@ -108,5 +126,13 @@ export function dispatchError(error: AmazonCognitoIdentityJsError) {
     ErrorType = CognitoError;
   }
 
+  // Special case: When requesting password reset, this can be thrown
+  if (
+    ErrorType === InvalidAuthorizationError &&
+    error.message === 'User password cannot be reset in the current state.'
+  ) {
+    ErrorType = PasswordCannotBeResetError;
+  }
+
   return ErrorType ? new ErrorType(error) : new CognitoError(error);
 }

tests/unit/errors/cognito-test.ts

@@ -0,0 +1,141 @@
+import {
+  CognitoError,
+  InvalidAuthorizationError,
+  UserNotFoundError,
+  PasswordResetRequiredError,
+  VerificationCodeMismatchError,
+  VerificationCodeExpiredError,
+  InvalidPasswordError,
+  PasswordCannotBeResetError,
+  dispatchError,
+} from 'ember-cognito-identity/errors/cognito';
+import { module, test } from 'qunit';
+
+module('Unit | Utility | errors/cognito', function () {
+  test('it works for a string', function (assert) {
+    // @ts-ignore
+    let result = dispatchError('test error');
+    assert.ok(result instanceof CognitoError);
+    assert.equal(result.message, 'test error');
+  });
+
+  test('it works with null', function (assert) {
+    // @ts-ignore
+    let result = dispatchError(null);
+    assert.ok(result instanceof CognitoError);
+    assert.equal(result.message, 'An error has occurred.');
+  });
+
+  test('it works for PasswordResetRequiredException', function (assert) {
+    let result = dispatchError({
+      code: 'PasswordResetRequiredException',
+      name: 'PasswordResetRequiredException',
+      message: 'test message',
+    });
+
+    assert.ok(result instanceof PasswordResetRequiredError);
+    assert.equal(result.message, 'Password reset required for the user.');
+  });
+
+  test('it works for NotAuthorizedException', function (assert) {
+    let result = dispatchError({
+      code: 'NotAuthorizedException',
+      name: 'NotAuthorizedException',
+      message: 'test message',
+    });
+
+    assert.ok(result instanceof InvalidAuthorizationError);
+    assert.equal(result.message, 'The password you provided is incorrect.');
+  });
+
+  test('it works for CodeMismatchException', function (assert) {
+    let result = dispatchError({
+      code: 'CodeMismatchException',
+      name: 'CodeMismatchException',
+      message: 'test message',
+    });
+
+    assert.ok(result instanceof VerificationCodeMismatchError);
+    assert.equal(
+      result.message,
+      'Invalid verification code provided, please try again.'
+    );
+  });
+
+  test('it works for InvalidPasswordException', function (assert) {
+    let result = dispatchError({
+      code: 'InvalidPasswordException',
+      name: 'InvalidPasswordException',
+      message: 'test message',
+    });
+
+    assert.ok(result instanceof InvalidPasswordError);
+    assert.equal(result.message, 'test message');
+  });
+
+  test('it works for InvalidParameterException', function (assert) {
+    let result = dispatchError({
+      code: 'InvalidParameterException',
+      name: 'InvalidParameterException',
+      message: 'test message',
+    });
+
+    assert.ok(result instanceof InvalidPasswordError);
+    assert.equal(result.message, 'test message');
+  });
+
+  test('it works for UserNotFoundException', function (assert) {
+    let result = dispatchError({
+      code: 'UserNotFoundException',
+      name: 'UserNotFoundException',
+      message: 'test message',
+    });
+
+    assert.ok(result instanceof UserNotFoundError);
+    assert.equal(result.message, 'This user does not exist.');
+  });
+
+  test('it works for ExpiredCodeException', function (assert) {
+    let result = dispatchError({
+      code: 'ExpiredCodeException',
+      name: 'ExpiredCodeException',
+      message: 'test message',
+    });
+
+    assert.ok(result instanceof VerificationCodeExpiredError);
+    assert.equal(
+      result.message,
+      'The verification code is expired, please request a new one.'
+    );
+  });
+
+  module('special cases', function () {
+    test('it handles updating invalid attributes', function (assert) {
+      let result = dispatchError({
+        name: 'NotAuthorizedException',
+        code: 'NotAuthorizedException',
+        message: 'A client attempted to write unauthorized attribute',
+      });
+
+      assert.ok(result instanceof CognitoError);
+      assert.equal(
+        result.message,
+        'A client attempted to write unauthorized attribute'
+      );
+    });
+
+    test('it handles requesting a password reset for an inactive user', function (assert) {
+      let result = dispatchError({
+        name: 'NotAuthorizedException',
+        code: 'NotAuthorizedException',
+        message: 'User password cannot be reset in the current state.',
+      });
+
+      assert.ok(result instanceof PasswordCannotBeResetError);
+      assert.equal(
+        result.message,
+        'The user you are trying to reset the password for is not active.'
+      );
+    });
+  });
+});