refactor(adminform): update form collab

src/app/models/__tests__/form.server.model.spec.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 import { ObjectId } from 'bson-ext'
-import { cloneDeep, merge, omit, orderBy, pick } from 'lodash'
+import { cloneDeep, map, merge, omit, orderBy, pick } from 'lodash'
 import mongoose, { Types } from 'mongoose'
 
 import getFormModel, {
@@ -1625,5 +1625,45 @@ describe('Form Model', () => {
         expect(updatedForm).toBeNull()
       })
     })
+
+    describe('updateFormCollaborators', () => {
+      it('should return the form with an updated list of collaborators', async () => {
+        // Arrange
+        const newCollaborators = [
+          {
+            email: `fakeuser@${MOCK_ADMIN_DOMAIN}`,
+            write: false,
+          },
+        ]
+
+        // Act
+        const actual = await validForm.updateFormCollaborators(newCollaborators)
+
+        // Assert
+        const actualPermissionsWithoutId = map(
+          actual.permissionList,
+          (collaborator) => pick(collaborator, ['email', 'write']),
+        )
+        expect(actualPermissionsWithoutId).toEqual(newCollaborators)
+      })
+
+      it('should return an error if validation fails', async () => {
+        // Arrange
+        const newCollaborators = [
+          {
+            email: `[email protected]`,
+            write: false,
+          },
+        ]
+
+        // Act
+        const actual = await validForm
+          .updateFormCollaborators(newCollaborators)
+          .catch((error) => error)
+
+        // Assert
+        expect(actual).toBeInstanceOf(mongoose.Error.ValidationError)
+      })
+    })
   })
 })

src/app/models/form.server.model.ts

@@ -523,6 +523,14 @@ const compileFormModel = (db: Mongoose): IFormModel => {
     return this.save()
   }
 
+  FormDocumentSchema.methods.updateFormCollaborators = async function (
+    this: IFormDocument,
+    updatedPermissions: Permission[],
+  ) {
+    this.permissionList = updatedPermissions
+    return this.save()
+  }
+
   FormDocumentSchema.methods.updateFormFieldById = function (
     this: IFormDocument,
     fieldId: string,

src/app/modules/form/admin-form/__tests__/admin-form.controller.spec.ts

@@ -1,5 +1,6 @@
 import { PresignedPost } from 'aws-sdk/clients/s3'
 import { ObjectId } from 'bson-ext'
+import { StatusCodes } from 'http-status-codes'
 import { assignIn, cloneDeep, merge, pick } from 'lodash'
 import { err, errAsync, ok, okAsync, Result } from 'neverthrow'
 import { PassThrough } from 'stream'
@@ -7818,4 +7819,181 @@ describe('admin-form.controller', () => {
       })
     })
   })
+
+  describe('_handleUpdateCollaborators', () => {
+    const MOCK_USER_ID = new ObjectId().toHexString()
+    const MOCK_FORM_ID = new ObjectId().toHexString()
+    const MOCK_USER = {
+      _id: MOCK_USER_ID,
+      email: '[email protected]',
+    } as IPopulatedUser
+    const MOCK_FORM = {
+      admin: MOCK_USER,
+      _id: MOCK_FORM_ID,
+    } as IPopulatedForm
+    const MOCK_COLLABORATORS = [
+      {
+        email: `[email protected]`,
+        write: false,
+      },
+    ]
+    const MOCK_REQ = expressHandler.mockRequest({
+      params: {
+        formId: MOCK_FORM_ID,
+      },
+      body: { permissionList: MOCK_COLLABORATORS },
+      session: {
+        user: {
+          _id: MOCK_USER_ID,
+        },
+      },
+    })
+
+    beforeEach(() => {
+      // Mock various services to return expected results.
+      MockUserService.getPopulatedUserById.mockReturnValue(okAsync(MOCK_USER))
+      MockAuthService.getFormAfterPermissionChecks.mockReturnValue(
+        okAsync(MOCK_FORM),
+      )
+    })
+    it('should return 200 when collaborators are updated successfully', async () => {
+      // Arrange
+      MockAdminFormService.updateFormCollaborators.mockReturnValueOnce(
+        okAsync(MOCK_COLLABORATORS),
+      )
+      const mockRes = expressHandler.mockResponse()
+      const expectedResponse = { permissionList: MOCK_COLLABORATORS }
+
+      // Act
+      await AdminFormController._handleUpdateCollaborators(
+        MOCK_REQ,
+        mockRes,
+        jest.fn(),
+      )
+
+      // Assert
+      expect(mockRes.status).toBeCalledWith(StatusCodes.OK)
+      expect(mockRes.json).toBeCalledWith(expectedResponse)
+    })
+
+    it('should return 403 when the user does not have sufficient permissions to update the form', async () => {
+      // Arrange
+      const ERROR_MESSAGE = 'all your base are belong to us'
+      MockAuthService.getFormAfterPermissionChecks.mockReturnValueOnce(
+        errAsync(new ForbiddenFormError(ERROR_MESSAGE)),
+      )
+      const mockRes = expressHandler.mockResponse()
+      const expectedResponse = { message: ERROR_MESSAGE }
+
+      // Act
+      await AdminFormController._handleUpdateCollaborators(
+        MOCK_REQ,
+        mockRes,
+        jest.fn(),
+      )
+
+      // Assert
+      expect(mockRes.status).toBeCalledWith(StatusCodes.FORBIDDEN)
+      expect(mockRes.json).toBeCalledWith(expectedResponse)
+      expect(
+        MockAdminFormService.updateFormCollaborators,
+      ).not.toHaveBeenCalled()
+    })
+
+    it('should return 404 when the form could not be found', async () => {
+      // Arrange
+      const ERROR_MESSAGE = 'all your base are belong to us'
+      MockAuthService.getFormAfterPermissionChecks.mockReturnValueOnce(
+        errAsync(new FormNotFoundError(ERROR_MESSAGE)),
+      )
+      const mockRes = expressHandler.mockResponse()
+      const expectedResponse = { message: ERROR_MESSAGE }
+
+      // Act
+      await AdminFormController._handleUpdateCollaborators(
+        MOCK_REQ,
+        mockRes,
+        jest.fn(),
+      )
+
+      // Assert
+      expect(mockRes.status).toBeCalledWith(StatusCodes.NOT_FOUND)
+      expect(mockRes.json).toBeCalledWith(expectedResponse)
+      expect(
+        MockAdminFormService.updateFormCollaborators,
+      ).not.toHaveBeenCalled()
+    })
+
+    it('should return 410 when the form has been archived', async () => {
+      // Arrange
+      const ERROR_MESSAGE = 'all your base are belong to us'
+      MockAuthService.getFormAfterPermissionChecks.mockReturnValueOnce(
+        errAsync(new FormDeletedError(ERROR_MESSAGE)),
+      )
+      const mockRes = expressHandler.mockResponse()
+      const expectedResponse = { message: ERROR_MESSAGE }
+
+      // Act
+      await AdminFormController._handleUpdateCollaborators(
+        MOCK_REQ,
+        mockRes,
+        jest.fn(),
+      )
+
+      // Assert
+      expect(mockRes.status).toBeCalledWith(StatusCodes.GONE)
+      expect(mockRes.json).toBeCalledWith(expectedResponse)
+      expect(
+        MockAdminFormService.updateFormCollaborators,
+      ).not.toHaveBeenCalled()
+    })
+
+    it('should return 422 when the session user could not be retrieved from the database', async () => {
+      // Arrange
+      const ERROR_MESSAGE = 'all your base are belong to us'
+      MockUserService.getPopulatedUserById.mockReturnValueOnce(
+        errAsync(new MissingUserError(ERROR_MESSAGE)),
+      )
+      const expectedResponse = { message: ERROR_MESSAGE }
+      const mockRes = expressHandler.mockResponse()
+
+      // Act
+      await AdminFormController._handleUpdateCollaborators(
+        MOCK_REQ,
+        mockRes,
+        jest.fn(),
+      )
+
+      // Assert
+      expect(mockRes.status).toBeCalledWith(StatusCodes.UNPROCESSABLE_ENTITY)
+      expect(mockRes.json).toBeCalledWith(expectedResponse)
+      expect(
+        MockAdminFormService.updateFormCollaborators,
+      ).not.toHaveBeenCalled()
+    })
+
+    it('should return 500 when a database error occurs', async () => {
+      // Arrange
+      const ERROR_MESSAGE = 'all your base are belong to us'
+      MockUserService.getPopulatedUserById.mockReturnValueOnce(
+        errAsync(new DatabaseError(ERROR_MESSAGE)),
+      )
+      const expectedResponse = { message: ERROR_MESSAGE }
+      const mockRes = expressHandler.mockResponse()
+
+      // Act
+      await AdminFormController._handleUpdateCollaborators(
+        MOCK_REQ,
+        mockRes,
+        jest.fn(),
+      )
+
+      // Assert
+      expect(mockRes.status).toBeCalledWith(StatusCodes.INTERNAL_SERVER_ERROR)
+      expect(mockRes.json).toBeCalledWith(expectedResponse)
+      expect(
+        MockAdminFormService.updateFormCollaborators,
+      ).not.toHaveBeenCalled()
+    })
+  })
 })

src/app/modules/form/admin-form/__tests__/admin-form.service.spec.ts

@@ -12,6 +12,7 @@ import getFormModel, {
   getEncryptedFormModel,
 } from 'src/app/models/form.server.model'
 import {
+  ApplicationError,
   DatabaseConflictError,
   DatabaseError,
   DatabasePayloadSizeError,
@@ -67,6 +68,7 @@ import {
   reorderFormField,
   transferFormOwnership,
   updateForm,
+  updateFormCollaborators,
   updateFormField,
   updateFormSettings,
 } from '../admin-form.service'
@@ -1543,4 +1545,56 @@ describe('admin-form.service', () => {
       )
     })
   })
+
+  describe('updateFormCollaborators', () => {
+    it('should return the list of collaborators when update is successful', async () => {
+      // Arrange
+      const newCollaborators = [
+        {
+          email: `[email protected]`,
+          write: false,
+        },
+      ]
+      const mockForm = ({
+        title: 'some mock form',
+        updateFormCollaborators: jest
+          .fn()
+          .mockResolvedValue({ permissionList: newCollaborators }),
+      } as unknown) as IPopulatedForm
+
+      // Act
+      const actual = await updateFormCollaborators(mockForm, newCollaborators)
+
+      // Assert
+      expect(mockForm.updateFormCollaborators).toHaveBeenCalledWith(
+        newCollaborators,
+      )
+      expect(actual._unsafeUnwrap()).toEqual(newCollaborators)
+    })
+
+    it('should return an application error when updating the form model fails', async () => {
+      // Arrange
+      const newCollaborators = [
+        {
+          email: `[email protected]`,
+          write: false,
+        },
+      ]
+      const mockForm = ({
+        title: 'some mock form',
+        updateFormCollaborators: jest
+          .fn()
+          .mockRejectedValue(new DatabaseError()),
+      } as unknown) as IPopulatedForm
+
+      // Act
+      const actual = await updateFormCollaborators(mockForm, newCollaborators)
+
+      // Assert
+      expect(mockForm.updateFormCollaborators).toHaveBeenCalledWith(
+        newCollaborators,
+      )
+      expect(actual._unsafeUnwrapErr()).toBeInstanceOf(ApplicationError)
+    })
+  })
 })