packages/docs-core/lib/Services/Websockets/Debouncer/UpdateDebouncer.spec.ts

   1 import { DecryptedValue } from '@proton/docs-proto'
   2 import type { NodeMeta } from '@proton/drive-store/lib'
   3 import { UpdateDebouncer } from './UpdateDebouncer'
   4 import { DocumentDebounceMode } from './DocumentDebounceMode'
   5 import type { LoggerInterface } from '@proton/utils/logs'
   6
   7 describe('UpdateDebouncer', () => {
   8   let debouncer: UpdateDebouncer
   9   let onEvent = jest.fn()
  10
  11   beforeEach(() => {
  12     debouncer = new UpdateDebouncer(
  13       {} as NodeMeta,
  14       {
  15         info: jest.fn(),
  16         debug: jest.fn(),
  17       } as unknown as LoggerInterface,
  18       onEvent,
  19     )
  20
  21     debouncer.isReadyToFlush = true
  22   })
  23
  24   afterEach(() => {
  25     debouncer.destroy()
  26     jest.clearAllMocks()
  27   })
  28
  29   describe('markAsReadyToFlush', () => {
  30     it('should set isReadyToFlush to true', () => {
  31       debouncer.isReadyToFlush = false
  32
  33       debouncer.markAsReadyToFlush()
  34
  35       expect(debouncer.isReadyToFlush).toBe(true)
  36     })
  37
  38     it('should flush', () => {
  39       debouncer.flush = jest.fn()
  40
  41       debouncer.markAsReadyToFlush()
  42
  43       expect(debouncer.flush).toHaveBeenCalledTimes(1)
  44     })
  45   })
  46
  47   describe('addUpdate', () => {
  48     it('should add to buffer regardless of mode', () => {
  49       debouncer.setMode(DocumentDebounceMode.SinglePlayer)
  50       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
  51
  52       expect(debouncer.buffer.length).toBe(1)
  53
  54       debouncer.setMode(DocumentDebounceMode.Realtime)
  55       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
  56
  57       expect(debouncer.buffer.length).toBe(2)
  58     })
  59
  60     it('should post WillFlush event', () => {
  61       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
  62
  63       expect(onEvent).toHaveBeenCalledTimes(1)
  64     })
  65
  66     it('should clear existing single player idle timeout', () => {
  67       debouncer.setMode(DocumentDebounceMode.SinglePlayer)
  68
  69       jest.useFakeTimers()
  70
  71       const previousTimeout = debouncer.singlePlayerIdleTimeout
  72
  73       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
  74
  75       expect(debouncer.singlePlayerIdleTimeout).not.toBe(previousTimeout)
  76     })
  77
  78     it('should flush after single player debounce period', () => {
  79       jest.useFakeTimers()
  80
  81       debouncer.flush = jest.fn()
  82
  83       debouncer.setMode(DocumentDebounceMode.SinglePlayer)
  84       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
  85
  86       jest.advanceTimersByTime(debouncer.singlePlayerDebouncePeriod)
  87
  88       expect(debouncer.flush).toHaveBeenCalledTimes(1)
  89     })
  90
  91     it('should increment current buffer size', () => {
  92       const data = new Uint8Array([1, 2, 3, 4, 5])
  93       debouncer.addUpdates([new DecryptedValue(data)])
  94
  95       expect(debouncer.currentBufferSize).toBe(data.byteLength)
  96     })
  97
  98     it('should not flush if size limit is not exceeded', () => {
  99       debouncer.flush = jest.fn()
 100
 101       const maxSize = debouncer.maxSizeBeforeFlush
 102
 103       debouncer.addUpdates([new DecryptedValue(new Uint8Array(maxSize - 1))])
 104
 105       expect(debouncer.flush).not.toHaveBeenCalled()
 106     })
 107
 108     it('should flush if size limit is exceeded', () => {
 109       debouncer.flush = jest.fn()
 110
 111       const maxSize = debouncer.maxSizeBeforeFlush
 112
 113       debouncer.addUpdates([new DecryptedValue(new Uint8Array(maxSize))])
 114
 115       expect(debouncer.flush).toHaveBeenCalledTimes(1)
 116     })
 117   })
 118
 119   describe('hasPendingUpdates', () => {
 120     it('should return false if buffer is empty', () => {
 121       expect(debouncer.hasPendingUpdates()).toBe(false)
 122     })
 123
 124     it('should return true if buffer has updates', () => {
 125       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 126
 127       expect(debouncer.hasPendingUpdates()).toBe(true)
 128     })
 129   })
 130
 131   describe('flush', () => {
 132     it('should do nothing if buffer is empty', () => {
 133       debouncer.flush()
 134
 135       expect(onEvent).not.toHaveBeenCalled()
 136     })
 137
 138     it('should abort if not ready to flush', () => {
 139       debouncer.isReadyToFlush = false
 140       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 141
 142       onEvent = jest.fn()
 143       debouncer.flush()
 144
 145       expect(onEvent).not.toHaveBeenCalled()
 146     })
 147
 148     it('should reset the current buffer size', () => {
 149       debouncer.addUpdates([new DecryptedValue(new Uint8Array([1]))])
 150
 151       expect(debouncer.currentBufferSize).toBeGreaterThan(0)
 152
 153       debouncer.flush()
 154
 155       expect(debouncer.currentBufferSize).toBe(0)
 156     })
 157
 158     it('should flush buffer', () => {
 159       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 160       debouncer.flush()
 161
 162       expect(onEvent).toHaveBeenCalledTimes(2)
 163       expect(debouncer.buffer.length).toBe(0)
 164     })
 165   })
 166
 167   describe('setMode', () => {
 168     it('should set realtime mode', () => {
 169       debouncer.setMode(DocumentDebounceMode.Realtime)
 170
 171       expect(debouncer.getMode()).toBe(DocumentDebounceMode.Realtime)
 172     })
 173
 174     it('should set singleplayer mode', () => {
 175       debouncer.setMode(DocumentDebounceMode.SinglePlayer)
 176
 177       expect(debouncer.getMode()).toBe(DocumentDebounceMode.SinglePlayer)
 178     })
 179
 180     it('should set realtime streaming interval if realtime mode', () => {
 181       expect(debouncer.realtimeStreamingInterval).not.toBeTruthy()
 182
 183       debouncer.setMode(DocumentDebounceMode.Realtime)
 184
 185       expect(debouncer.realtimeStreamingInterval).toBeTruthy()
 186     })
 187
 188     it('should clear realtime streaming interval if not realtime mode', () => {
 189       debouncer.setMode(DocumentDebounceMode.Realtime)
 190
 191       expect(debouncer.realtimeStreamingInterval).toBeTruthy()
 192
 193       debouncer.setMode(DocumentDebounceMode.SinglePlayer)
 194
 195       expect(debouncer.realtimeStreamingInterval).not.toBeTruthy()
 196     })
 197   })
 198
 199   describe('realtime mode', () => {
 200     it('should flush after realtime streaming period', () => {
 201       jest.useFakeTimers()
 202
 203       debouncer.flush = jest.fn()
 204
 205       debouncer.setMode(DocumentDebounceMode.Realtime)
 206
 207       jest.advanceTimersByTime(debouncer.realtimeStreamingPeriod)
 208
 209       expect(debouncer.flush).toHaveBeenCalledTimes(1)
 210     })
 211   })
 212
 213   describe('singleplayer mode', () => {
 214     it('should flush after debounce period', () => {
 215       jest.useFakeTimers()
 216
 217       debouncer.flush = jest.fn()
 218
 219       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 220
 221       jest.advanceTimersByTime(debouncer.singlePlayerDebouncePeriod)
 222
 223       expect(debouncer.flush).toHaveBeenCalledTimes(1)
 224     })
 225
 226     it('should not flush if debounce period passes but updates are still being added', () => {
 227       jest.useFakeTimers()
 228
 229       debouncer.flush = jest.fn()
 230
 231       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 232
 233       jest.advanceTimersByTime(debouncer.singlePlayerDebouncePeriod - 100)
 234
 235       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 236
 237       jest.advanceTimersByTime(debouncer.singlePlayerDebouncePeriod - 100)
 238
 239       expect(debouncer.flush).not.toHaveBeenCalled()
 240     })
 241
 242     it('debounce period should reset after adding a new update', () => {
 243       debouncer.flush = jest.fn()
 244
 245       jest.useFakeTimers()
 246
 247       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 248
 249       jest.advanceTimersByTime(debouncer.singlePlayerDebouncePeriod / 2)
 250
 251       debouncer.addUpdates([new DecryptedValue(new Uint8Array())])
 252
 253       jest.advanceTimersByTime(debouncer.singlePlayerDebouncePeriod / 2)
 254
 255       expect(debouncer.flush).not.toHaveBeenCalled()
 256
 257       jest.advanceTimersByTime(debouncer.singlePlayerDebouncePeriod / 2)
 258
 259       expect(debouncer.flush).toHaveBeenCalledTimes(1)
 260     })
 261   })
 262 })