feat: add sending user requests to process (#1908)

* feat: add sending user requests to process

* fix(snjs): yarn lock

* fix(snjs): imports

* fix: specs

packages/api/src/Domain/Client/User/UserApiService.spec.ts

@@ -1,20 +1,35 @@
-import { ProtocolVersion } from '@standardnotes/common'
+import { ProtocolVersion, UserRequestType } from '@standardnotes/common'
 import { RootKeyParamsInterface } from '@standardnotes/models'
+import { UserDeletionResponse } from '../../Response/User/UserDeletionResponse'
+
 import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
+import { UserRequestResponse } from '../../Response/UserRequest/UserRequestResponse'
 import { UserServerInterface } from '../../Server'
+import { UserRequestServerInterface } from '../../Server/UserRequest/UserRequestServerInterface'
+
+import { UserApiOperations } from './UserApiOperations'
 import { UserApiService } from './UserApiService'
 
 describe('UserApiService', () => {
   let userServer: UserServerInterface
+  let userRequestServer: UserRequestServerInterface
   let keyParams: RootKeyParamsInterface
 
-  const createService = () => new UserApiService(userServer)
+  const createService = () => new UserApiService(userServer, userRequestServer)
 
   beforeEach(() => {
     userServer = {} as jest.Mocked<UserServerInterface>
     userServer.register = jest.fn().mockReturnValue({
       data: { user: { email: 'test@test.te', uuid: '1-2-3' } },
     } as jest.Mocked<UserRegistrationResponse>)
+    userServer.deleteAccount = jest.fn().mockReturnValue({
+      data: { message: 'Success' },
+    } as jest.Mocked<UserDeletionResponse>)
+
+    userRequestServer = {} as jest.Mocked<UserRequestServerInterface>
+    userRequestServer.submitUserRequest = jest.fn().mockReturnValue({
+      data: { success: true },
+    } as jest.Mocked<UserRequestResponse>)
 
     keyParams = {} as jest.Mocked<RootKeyParamsInterface>
     keyParams.getPortableValue = jest.fn().mockReturnValue({
@@ -51,8 +66,8 @@ describe('UserApiService', () => {
 
   it('should not register a user if it is already registering', async () => {
     const service = createService()
-    Object.defineProperty(service, 'registering', {
-      get: () => true,
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[UserApiOperations.Registering, true]]),
     })
 
     let error = null
@@ -84,4 +99,99 @@ describe('UserApiService', () => {
 
     expect(error).not.toBeNull()
   })
+
+  it('should submit a user request', async () => {
+    const response = await createService().submitUserRequest({
+      userUuid: '1-2-3',
+      requestType: UserRequestType.ExitDiscount,
+    })
+
+    expect(response).toEqual({
+      data: {
+        success: true,
+      },
+    })
+    expect(userRequestServer.submitUserRequest).toHaveBeenCalledWith({
+      userUuid: '1-2-3',
+      requestType: UserRequestType.ExitDiscount,
+    })
+  })
+
+  it('should not submit a user request if it is already submitting', async () => {
+    const service = createService()
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[UserApiOperations.SubmittingRequest, true]]),
+    })
+
+    let error = null
+    try {
+      await service.submitUserRequest({ userUuid: '1-2-3', requestType: UserRequestType.ExitDiscount })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should not submit a user request if the server fails', async () => {
+    userRequestServer.submitUserRequest = jest.fn().mockImplementation(() => {
+      throw new Error('Oops')
+    })
+
+    let error = null
+    try {
+      await createService().submitUserRequest({
+        userUuid: '1-2-3',
+        requestType: UserRequestType.ExitDiscount,
+      })
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should delete a user', async () => {
+    const response = await createService().deleteAccount('1-2-3')
+
+    expect(response).toEqual({
+      data: {
+        message: 'Success',
+      },
+    })
+    expect(userServer.deleteAccount).toHaveBeenCalledWith({
+      userUuid: '1-2-3',
+    })
+  })
+
+  it('should not delete a user if it is already deleting', async () => {
+    const service = createService()
+    Object.defineProperty(service, 'operationsInProgress', {
+      get: () => new Map([[UserApiOperations.DeletingAccount, true]]),
+    })
+
+    let error = null
+    try {
+      await service.deleteAccount('1-2-3')
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
+
+  it('should not delete a user if the server fails', async () => {
+    userServer.deleteAccount = jest.fn().mockImplementation(() => {
+      throw new Error('Oops')
+    })
+
+    let error = null
+    try {
+      await createService().deleteAccount('1-2-3')
+    } catch (caughtError) {
+      error = caughtError
+    }
+
+    expect(error).not.toBeNull()
+  })
 })