SANDBOX-1893 | Show alerts for user signup errors

plugins/sandbox/src/api/RegistrationBackendClient.tsx

@@ -20,6 +20,7 @@ import { isValidCountryCode, isValidPhoneNumber } from '../utils/phone-utils';
 import { CommonResponse, SignupData } from '../types';
 import { SecureFetchApi } from './SecureFetchClient';
 import { SandboxEnvironment } from '../const';
+import UserSignupError from './errors/UserSignupError';
 
 export type RegistrationBackendClientOptions = {
   configApi: ConfigApi;
@@ -67,20 +68,28 @@ export class RegistrationBackendClient implements RegistrationService {
     );
   };
 
+  /**
+   * Get the "UserSignup" resource for the current user.
+   * @returns the current user's signup resource or code undefined it is not
+   * found.
+   */
   getSignUpData = async (): Promise<SignupData | undefined> => {
     const signupURL = await this.signupAPI();
     const response = await this.secureFetchApi.fetch(signupURL, {
       method: 'GET',
     });
-    if (!response.ok) {
-      if (response.status === 404) {
-        return undefined;
-      }
-      throw new Error(
-        `Unexpected status code: ${response.status} ${response.statusText}`,
-      );
+    if (response.ok) {
+      return response.json();
     }
-    return response.json();
+
+    // The user signup is not found, we return undefined to signal that it is
+    // safe to create it instead.
+    if (response.status === 404) {
+      return undefined;
+    }
+
+    // At this point we need to signal the user that something went wrong.
+    throw await UserSignupError.fromResponse(response);
   };
 
   getRecaptchaToken = async (): Promise<string> => {

plugins/sandbox/src/api/__tests__/RegistrationBackendClient.test.tsx

@@ -17,35 +17,8 @@
 import { ConfigApi } from '@backstage/core-plugin-api';
 import { RegistrationBackendClient } from '../RegistrationBackendClient';
 import { SecureFetchApi } from '../SecureFetchClient';
-
-// Helper to create a mock Response object
-const createMockResponse = (options: {
-  ok: boolean;
-  status?: number;
-  statusText?: string;
-  json?: () => Promise<any>;
-}): Response => {
-  const { ok, status = 200, statusText = '', json } = options;
-  return {
-    ok,
-    status,
-    statusText,
-    headers: new Headers(),
-    redirected: false,
-    type: 'basic',
-    url: 'http://mock',
-    json: json || (() => Promise.resolve({})),
-    text: () => Promise.resolve(''),
-    blob: () => Promise.resolve(new Blob()),
-    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-    formData: () => Promise.resolve(new FormData()),
-    bodyUsed: false,
-    body: null,
-    clone: function () {
-      return this;
-    },
-  } as Response;
-};
+import { createMockResponse } from '../../test-utils/mockResponse';
+import UserSignupError from '../errors/UserSignupError';
 
 describe('RegistrationBackendClient', () => {
   let mockConfigApi: jest.Mocked<ConfigApi>;
@@ -103,7 +76,7 @@ describe('RegistrationBackendClient', () => {
       expect(result).toEqual(mockData);
     });
 
-    it('should return undefined on 404 response', async () => {
+    it('should return undefined on a 404 response', async () => {
       mockConfigApi.getString.mockReturnValue('http://api');
       mockSecureFetchApi.fetch.mockResolvedValue(
         createMockResponse({
@@ -116,7 +89,7 @@ describe('RegistrationBackendClient', () => {
       expect(result).toBeUndefined();
     });
 
-    it('should throw error on other unsuccessful responses', async () => {
+    it('should throw a UserSignupError on a 500 response', async () => {
       mockConfigApi.getString.mockReturnValue('http://api');
       mockSecureFetchApi.fetch.mockResolvedValue(
         createMockResponse({
@@ -126,8 +99,28 @@ describe('RegistrationBackendClient', () => {
         }),
       );
 
+      await expect(client.getSignUpData()).rejects.toThrow(UserSignupError);
+      await expect(client.getSignUpData()).rejects.toThrow(
+        'Unable to sign you up into Developer Sandbox. Please contact devsandbox@redhat.com',
+      );
+    });
+
+    it('should throw a UserSignupError with the correct message for a known error', async () => {
+      mockConfigApi.getString.mockReturnValue('http://api');
+      mockSecureFetchApi.fetch.mockResolvedValue(
+        createMockResponse({
+          ok: false,
+          status: 403,
+          json: () =>
+            Promise.resolve({
+              message: 'user has been suspended',
+            }),
+        }),
+      );
+
+      await expect(client.getSignUpData()).rejects.toThrow(UserSignupError);
       await expect(client.getSignUpData()).rejects.toThrow(
-        'Unexpected status code: 500 Server Error',
+        'Access to the Developer Sandbox has been suspended due to suspicious activity or detected abuse',
       );
     });
   });

plugins/sandbox/src/api/__tests__/UserSignupError.test.ts

@@ -0,0 +1,165 @@
+import { createMockResponse } from '../../test-utils/mockResponse';
+import UserSignupError from '../errors/UserSignupError';
+
+describe('user signup error', () => {
+  const defaultErrorMessage: string =
+    'Unable to sign you up into Developer Sandbox. Please contact devsandbox@redhat.com';
+
+  it('sets a message when using the main constructor', () => {
+    const errorMsg = 'test error msg';
+
+    // Call the function under test.
+    const userSignupError = new UserSignupError(errorMsg);
+
+    expect(userSignupError.message).toBe(errorMsg);
+  });
+
+  it('returns the default error message on internal server errors', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 500,
+    });
+
+    // Call the function under test.
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(defaultErrorMessage);
+  });
+
+  it('returns the default error message when the response body is not valid JSON', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 400,
+      json: () => Promise.reject(new Error('invalid json')),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(defaultErrorMessage);
+  });
+
+  it('returns the default error message when the response body is null', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve(null),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(defaultErrorMessage);
+  });
+
+  it('returns the default error message when the response body has no message field', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 400,
+      json: () => Promise.resolve({ details: 'some detail' }),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(defaultErrorMessage);
+  });
+
+  it('returns the invalid code message with details', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 403,
+      json: () =>
+        Promise.resolve({
+          message: 'invalid code provided',
+          details: 'code ABC123 is not recognized',
+        }),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(
+      'The provided activation code is invalid: code ABC123 is not recognized',
+    );
+  });
+
+  it('returns the suspended message', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 403,
+      json: () =>
+        Promise.resolve({
+          message: 'user has been suspended',
+        }),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(
+      'Access to the Developer Sandbox has been suspended due to suspicious activity or detected abuse',
+    );
+  });
+
+  it('returns the denied message', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 403,
+      json: () =>
+        Promise.resolve({
+          message: 'user has been denied',
+        }),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(
+      'Access to the Developer Sandbox has been denied',
+    );
+  });
+
+  it('returns the admin not allowed message', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 403,
+      json: () =>
+        Promise.resolve({
+          message: 'failed to create usersignup for admin-user',
+        }),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(
+      'A CRT admin is not allowed to sign up',
+    );
+  });
+
+  it('returns the already signed up message', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 409,
+      json: () =>
+        Promise.resolve({
+          message: 'there is already an active UserSignup with such a username',
+        }),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(
+      'An account is already signed up to Developer Sandbox with your username',
+    );
+  });
+
+  it('returns the default error message for an unrecognized message', async () => {
+    const response = createMockResponse({
+      ok: false,
+      status: 400,
+      json: () =>
+        Promise.resolve({
+          message: 'some completely unexpected error from the backend',
+        }),
+    });
+
+    const userSignupError = await UserSignupError.fromResponse(response);
+
+    expect(userSignupError.message).toBe(defaultErrorMessage);
+  });
+});

plugins/sandbox/src/api/errors/UserSignupError.ts

@@ -0,0 +1,66 @@
+import { CommonResponse } from '../../types';
+
+/**
+ * Defines the error type that is useful for problems with the user's signup.
+ */
+export default class UserSignupError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+
+  /**
+   * Creates the error from the given response, by attempting to read and set
+   * a user friendly error message.
+   * @param response the response to process.
+   * @returns a user friendly error message.
+   */
+  static async fromResponse(response: Response): Promise<UserSignupError> {
+    const defaultErrorMessage: string =
+      'Unable to sign you up into Developer Sandbox. Please contact devsandbox@redhat.com';
+
+    if (response.status === 500) {
+      return new UserSignupError(defaultErrorMessage);
+    }
+
+    let body: CommonResponse | undefined;
+    try {
+      body = await response.json();
+    } catch {
+      return new UserSignupError(defaultErrorMessage);
+    }
+
+    if (!body || !body.message) {
+      return new UserSignupError(defaultErrorMessage);
+    }
+
+    const { message, details } = body;
+    switch (true) {
+      case message.includes('invalid code'): {
+        const baseErrMessage = 'The provided activation code is invalid';
+        if (details) {
+          return new UserSignupError(`${baseErrMessage}: ${details}`);
+        } else {
+          return new UserSignupError(baseErrMessage);
+        }
+      }
+      case message.includes('has been suspended'):
+        return new UserSignupError(
+          'Access to the Developer Sandbox has been suspended due to suspicious activity or detected abuse',
+        );
+      case message.includes('has been denied'):
+        return new UserSignupError(
+          'Access to the Developer Sandbox has been denied',
+        );
+      case message.includes('failed to create usersignup for'):
+        return new UserSignupError('A CRT admin is not allowed to sign up');
+      case message.includes(
+        'there is already an active UserSignup with such a username',
+      ):
+        return new UserSignupError(
+          'An account is already signed up to Developer Sandbox with your username',
+        );
+      default:
+        return new UserSignupError(defaultErrorMessage);
+    }
+  }
+}