packages/docs-core/lib/UseCase/DecryptMessage.spec.ts

   1 import { Result } from '@proton/docs-shared'
   2 import type { EncryptionService } from '../Services/Encryption/EncryptionService'
   3 import type { EncryptionContext } from '../Services/Encryption/EncryptionContext'
   4 import type { DecryptMessageDTO } from './DecryptMessage'
   5 import { DecryptMessage } from './DecryptMessage'
   6 import type { DocumentUpdate } from '@proton/docs-proto'
   7 import type { SessionKey } from '@proton/crypto/lib'
   8
   9 describe('DecryptMessage', () => {
  10   let decryptMessage: DecryptMessage
  11   let encryptionSerivce: EncryptionService<EncryptionContext.RealtimeMessage>
  12
  13   const key = '' as unknown as SessionKey
  14
  15   beforeEach(() => {
  16     encryptionSerivce = {
  17       decryptData: jest.fn().mockReturnValue(Result.ok({ content: new Uint8Array(), signature: new Uint8Array() })),
  18       getVerificationKey: jest.fn().mockReturnValue(Result.ok(new Uint8Array())),
  19       verifyData: jest.fn().mockReturnValue(Result.ok(2)),
  20     } as unknown as jest.Mocked<EncryptionService<EncryptionContext.RealtimeMessage>>
  21     decryptMessage = new DecryptMessage(encryptionSerivce)
  22   })
  23
  24   it('should decrypt data', async () => {
  25     const dto: DecryptMessageDTO = {
  26       message: {
  27         content: new Uint8Array(),
  28         authorAddress: 'string',
  29         timestamp: 0,
  30         version: 0,
  31       } as unknown as jest.Mocked<DocumentUpdate>,
  32       documentContentKey: key,
  33       verify: true,
  34     }
  35     await decryptMessage.execute(dto)
  36
  37     expect(encryptionSerivce.decryptData).toHaveBeenCalled()
  38   })
  39
  40   it('should fetch verification key', async () => {
  41     const dto: DecryptMessageDTO = {
  42       message: {
  43         content: new Uint8Array(),
  44         authorAddress: 'string',
  45         timestamp: 0,
  46         version: 0,
  47       } as unknown as jest.Mocked<DocumentUpdate>,
  48       documentContentKey: key,
  49       verify: true,
  50     }
  51     await decryptMessage.execute(dto)
  52
  53     expect(encryptionSerivce.getVerificationKey).toHaveBeenCalled()
  54   })
  55
  56   it('should fail if cannot fetch verification key', async () => {
  57     ;(encryptionSerivce.getVerificationKey as jest.Mock).mockReturnValue(Result.fail('error'))
  58
  59     const dto: DecryptMessageDTO = {
  60       message: {
  61         content: new Uint8Array(),
  62         authorAddress: 'string',
  63         timestamp: 0,
  64         version: 0,
  65       } as unknown as jest.Mocked<DocumentUpdate>,
  66       documentContentKey: key,
  67       verify: true,
  68     }
  69
  70     const result = await decryptMessage.execute(dto)
  71
  72     expect(result.isFailed()).toBeTruthy()
  73   })
  74
  75   it('should verify data', async () => {
  76     const dto: DecryptMessageDTO = {
  77       message: {
  78         content: new Uint8Array(),
  79         authorAddress: 'string',
  80         timestamp: 0,
  81         version: 0,
  82       } as unknown as jest.Mocked<DocumentUpdate>,
  83       documentContentKey: key,
  84       verify: true,
  85     }
  86     await decryptMessage.execute(dto)
  87
  88     expect(encryptionSerivce.verifyData).toHaveBeenCalled()
  89   })
  90
  91   it('should fail if verification fails', async () => {
  92     ;(encryptionSerivce.verifyData as jest.Mock).mockReturnValue(Result.fail('error'))
  93
  94     const dto: DecryptMessageDTO = {
  95       message: {
  96         content: new Uint8Array(),
  97         authorAddress: 'string',
  98         timestamp: 0,
  99         version: 0,
 100       } as unknown as jest.Mocked<DocumentUpdate>,
 101       documentContentKey: key,
 102       verify: true,
 103     }
 104
 105     const result = await decryptMessage.execute(dto)
 106
 107     expect(result.isFailed()).toBeTruthy()
 108   })
 109
 110   it('should not verify if verify is false', async () => {
 111     const dto: DecryptMessageDTO = {
 112       message: {
 113         content: new Uint8Array(),
 114         authorAddress: 'string',
 115         timestamp: 0,
 116         version: 0,
 117       } as unknown as jest.Mocked<DocumentUpdate>,
 118       documentContentKey: key,
 119       verify: false,
 120     }
 121
 122     await decryptMessage.execute(dto)
 123
 124     expect(encryptionSerivce.verifyData).not.toHaveBeenCalled()
 125   })
 126 })