Merge pull request #1754 from AmbireTech/fixes/continuous-updates-tests

Fixes / ContinuousUpdatesController tests

Author: sonytooo

src/classes/recurringTimeout/recurringTimeout.ts

@@ -12,6 +12,7 @@ export interface IRecurringTimeout {
   updateTimeout: (options: { timeout: number }) => void
   running: boolean
   sessionId: number
+  fnExecutionsCount: number
   startedRunningAt: number
   currentTimeout: number
   promise: Promise<void> | undefined
@@ -30,6 +31,8 @@ export class RecurringTimeout implements IRecurringTimeout {
   // used mainly for testing how many times the fn was called
   sessionId: number = 0
 
+  fnExecutionsCount: number = 0
+
   running = false
 
   startedRunningAt: number = 0
@@ -64,6 +67,7 @@ export class RecurringTimeout implements IRecurringTimeout {
   }
 
   stop() {
+    this.startScheduled = false
     this.#reset()
   }
 
@@ -73,10 +77,9 @@ export class RecurringTimeout implements IRecurringTimeout {
   }
 
   async #loop() {
-    if (this.promise) return // prevents multiple executions in one tick
-
     try {
       this.promise = this.#fn()
+      this.fnExecutionsCount += 1
       await this.promise
     } catch (err: any) {
       if (!this.promise) return
@@ -113,6 +116,8 @@ export class RecurringTimeout implements IRecurringTimeout {
 
       if (newTimeout) this.updateTimeout({ timeout: newTimeout })
 
+      if (this.promise) return // prevents multiple executions in one tick
+
       if (runImmediately) {
         this.#loop()
       } else {
@@ -123,8 +128,6 @@ export class RecurringTimeout implements IRecurringTimeout {
 
   #reset() {
     this.running = false
-    this.promise = undefined
-    this.startScheduled = false
     this.startedRunningAt = 0
 
     if (this.#timeoutId) {

src/controllers/accounts/accounts.ts

@@ -49,6 +49,11 @@ export class AccountsController extends EventEmitter implements IAccountsControl
   // Holds the initial load promise, so that one can wait until it completes
   initialLoadPromise?: Promise<void>
 
+  // Tracks the initial load of account states. Unlike `initialLoadPromise`,
+  // this one isn’t awaited during the AccountsController initial load, so it’s the only
+  // reliable way to know when account states are fully loaded.
+  accountStatesInitialLoadPromise?: Promise<void>
+
   constructor(
     storage: IStorageController,
     providers: IProvidersController,
@@ -100,9 +105,11 @@ export class AccountsController extends EventEmitter implements IAccountsControl
     // NOTE: YOU MUST USE waitForAccountsCtrlFirstLoad IN TESTS
     // TO ENSURE ACCOUNT STATE IS LOADED
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    this.#updateAccountStates(
+    this.accountStatesInitialLoadPromise = this.#updateAccountStates(
       this.#getAccountsToUpdateAccountStatesInBackground(initialSelectedAccountAddr)
-    )
+    ).finally(() => {
+      this.accountStatesInitialLoadPromise = undefined
+    })
   }
 
   async updateAccountStates(

src/controllers/continuousUpdates/continuousUpdates.test.ts

@@ -1,14 +1,16 @@
 /* eslint-disable no-await-in-loop */
-/* eslint-disable prettier/prettier */
 import fetch from 'node-fetch'
 
+/* eslint-disable prettier/prettier */
 import { relayerUrl, velcroUrl } from '../../../test/config'
 import { produceMemoryStore } from '../../../test/helpers'
 import { mockUiManager } from '../../../test/helpers/ui'
 import { waitForFnToBeCalledAndExecuted } from '../../../test/recurringTimeout'
 import { ACCOUNT_STATE_PENDING_INTERVAL } from '../../consts/intervals'
+import { RPCProviders } from '../../interfaces/provider'
 import { SubmittedAccountOp } from '../../libs/accountOp/submittedAccountOp'
 import { KeystoreSigner } from '../../libs/keystoreSigner/keystoreSigner'
+import wait from '../../utils/wait'
 import { MainController } from '../main/main'
 
 // Public API key, shared by Socket, for testing purposes only
@@ -77,6 +79,12 @@ const submittedAccountOp = {
   }
 } as SubmittedAccountOp
 
+function filterProviders(providers: RPCProviders, chainIdsToFilter: string[] = []): RPCProviders {
+  return Object.fromEntries(
+    Object.entries(providers).filter(([key]) => chainIdsToFilter.includes(key))
+  ) as RPCProviders
+}
+
 const prepareTest = async () => {
   const storage = produceMemoryStore()
   await storage.set('accounts', accounts)
@@ -96,10 +104,16 @@ const prepareTest = async () => {
     velcroUrl
   })
   mainCtrl.portfolio.updateSelectedAccount = jest.fn().mockResolvedValue(undefined)
-  mainCtrl.updateSelectedAccountPortfolio = jest.fn().mockResolvedValue(undefined)
+  mainCtrl.updateSelectedAccountPortfolio = jest.fn().mockImplementation(async () => {
+    await wait(500)
+  })
   mainCtrl.domains.reverseLookup = jest.fn().mockResolvedValue(undefined)
-  mainCtrl.accounts.updateAccountStates = jest.fn().mockResolvedValue(undefined)
-  mainCtrl.accounts.updateAccountState = jest.fn().mockResolvedValue(undefined)
+  mainCtrl.accounts.updateAccountStates = jest.fn().mockImplementation(async () => {
+    await wait(500)
+  })
+  mainCtrl.accounts.updateAccountState = jest.fn().mockImplementation(async () => {
+    await wait(500)
+  })
   mainCtrl.updateAccountsOpsStatuses = jest.fn().mockResolvedValue({ newestOpTimestamp: 0 })
 
   return { mainCtrl }
@@ -121,6 +135,14 @@ const waitForContinuousUpdatesCtrlReady = async (mainCtrl: MainController) => {
   }
 }
 
+const waitForAccountStatesInitialLoad = async (mainCtrl: MainController) => {
+  await jest.advanceTimersByTimeAsync(0)
+
+  while (mainCtrl.accounts.accountStatesInitialLoadPromise) {
+    await jest.advanceTimersByTimeAsync(20)
+  }
+}
+
 describe('ContinuousUpdatesController intervals', () => {
   beforeEach(() => {
     jest.useFakeTimers()
@@ -135,29 +157,46 @@ describe('ContinuousUpdatesController intervals', () => {
   test('should run updatePortfolioInterval', async () => {
     const { mainCtrl } = await prepareTest()
     await waitForContinuousUpdatesCtrlReady(mainCtrl)
+    await waitForAccountStatesInitialLoad(mainCtrl)
+    const providersForTesting = ['1', '137']
+    const mockedProviders = filterProviders(mainCtrl.providers.providers, providersForTesting)
+    // ensure all providers are working
+    mockedProviders[1].isWorking = true
+    mockedProviders[137].isWorking = true
+    mainCtrl.providers.providers = mockedProviders
+
     jest.spyOn(mainCtrl.continuousUpdates.updatePortfolioInterval, 'restart')
-    const updatePortfolioSpy = jest.spyOn(mainCtrl.continuousUpdates, 'updatePortfolio')
     mainCtrl.ui.addView({ id: '1', type: 'popup', currentRoute: 'dashboard', isReady: true })
     await jest.advanceTimersByTimeAsync(0)
     expect(mainCtrl.continuousUpdates.updatePortfolioInterval.restart).toHaveBeenCalled()
     const updateSelectedAccountPortfolioSpy = jest.spyOn(mainCtrl, 'updateSelectedAccountPortfolio')
+    const initialFnExecutionsCount =
+      mainCtrl.continuousUpdates.updatePortfolioInterval.fnExecutionsCount
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.updatePortfolioInterval)
-    expect(updatePortfolioSpy).toHaveBeenCalledTimes(1)
+    expect(mainCtrl.continuousUpdates.updatePortfolioInterval.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 1
+    )
     const updateSelectedAccountCalledTimes = updateSelectedAccountPortfolioSpy.mock.calls.length
     await mainCtrl.activity.addAccountOp(submittedAccountOp)
     await jest.advanceTimersByTimeAsync(0)
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.updatePortfolioInterval)
-    expect(updatePortfolioSpy).toHaveBeenCalledTimes(2)
+    expect(mainCtrl.continuousUpdates.updatePortfolioInterval.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 2
+    )
     expect(updateSelectedAccountPortfolioSpy).toHaveBeenCalledTimes(
       updateSelectedAccountCalledTimes
     ) // tests the branching in the updatePortfolio func
     mainCtrl.ui.removeView('1')
     await jest.advanceTimersByTimeAsync(0)
     expect(mainCtrl.continuousUpdates.updatePortfolioInterval.restart).toHaveBeenCalledTimes(2)
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.updatePortfolioInterval)
-    expect(updatePortfolioSpy).toHaveBeenCalledTimes(3)
+    expect(mainCtrl.continuousUpdates.updatePortfolioInterval.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 3
+    )
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.updatePortfolioInterval)
-    expect(updatePortfolioSpy).toHaveBeenCalledTimes(4)
+    expect(mainCtrl.continuousUpdates.updatePortfolioInterval.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 4
+    )
   })
 
   test('should run accountsOpsStatusesInterval', async () => {
@@ -166,18 +205,22 @@ describe('ContinuousUpdatesController intervals', () => {
 
     jest.spyOn(mainCtrl.continuousUpdates.accountsOpsStatusesInterval, 'start')
     jest.spyOn(mainCtrl.continuousUpdates.accountsOpsStatusesInterval, 'stop')
-    const updateAccountsOpsStatuses = jest.spyOn(
-      mainCtrl.continuousUpdates,
-      'updateAccountsOpsStatuses'
-    )
 
     await mainCtrl.activity.addAccountOp(submittedAccountOp)
     await jest.advanceTimersByTimeAsync(0)
+
+    const initialFnExecutionsCount =
+      mainCtrl.continuousUpdates.accountsOpsStatusesInterval.fnExecutionsCount
+
     expect(mainCtrl.continuousUpdates.accountsOpsStatusesInterval.start).toHaveBeenCalled()
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.accountsOpsStatusesInterval)
-    expect(updateAccountsOpsStatuses).toHaveBeenCalledTimes(1)
+    expect(mainCtrl.continuousUpdates.accountsOpsStatusesInterval.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 1
+    )
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.accountsOpsStatusesInterval)
-    expect(updateAccountsOpsStatuses).toHaveBeenCalledTimes(2)
+    expect(mainCtrl.continuousUpdates.accountsOpsStatusesInterval.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 2
+    )
     jest.spyOn(mainCtrl.activity, 'broadcastedButNotConfirmed', 'get').mockReturnValue([])
     // @ts-ignore
     mainCtrl.activity.emitUpdate()
@@ -191,21 +234,21 @@ describe('ContinuousUpdatesController intervals', () => {
     jest.spyOn(mainCtrl.continuousUpdates.accountStateLatestInterval, 'restart')
     jest.spyOn(mainCtrl.continuousUpdates.accountStatePendingInterval, 'start')
     jest.spyOn(mainCtrl.continuousUpdates.accountStatePendingInterval, 'stop')
-    const updateAccountStateLatestMock = jest.spyOn(
-      mainCtrl.continuousUpdates,
-      'updateAccountStateLatest'
-    )
-    const updateAccountStatePendingMock = jest.spyOn(
-      mainCtrl.continuousUpdates,
-      'updateAccountStatePending'
-    )
 
     await waitForContinuousUpdatesCtrlReady(mainCtrl)
 
+    const initialAccountStateLatestFnExecutionsCount =
+      mainCtrl.continuousUpdates.accountStateLatestInterval.fnExecutionsCount
+
+    const initialAccountStatePendingFnExecutionsCount =
+      mainCtrl.continuousUpdates.accountStateLatestInterval.fnExecutionsCount
+
     expect(mainCtrl.continuousUpdates.accountStateLatestInterval.running).toBe(true)
     expect(mainCtrl.continuousUpdates.accountStatePendingInterval.running).toBe(false)
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.accountStateLatestInterval)
-    expect(updateAccountStateLatestMock).toHaveBeenCalledTimes(1)
+    expect(mainCtrl.continuousUpdates.accountStateLatestInterval.fnExecutionsCount).toBe(
+      initialAccountStateLatestFnExecutionsCount + 1
+    )
     mainCtrl.statuses.signAndBroadcastAccountOp = 'SUCCESS'
     // @ts-ignore
     mainCtrl.emitUpdate()
@@ -217,36 +260,76 @@ describe('ContinuousUpdatesController intervals', () => {
     expect(mainCtrl.continuousUpdates.accountStatePendingInterval.currentTimeout).toBe(
       ACCOUNT_STATE_PENDING_INTERVAL / 2
     )
+
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.accountStatePendingInterval)
-    expect(updateAccountStatePendingMock).toHaveBeenCalledTimes(1)
+    expect(mainCtrl.continuousUpdates.accountStatePendingInterval.fnExecutionsCount).toBe(
+      initialAccountStatePendingFnExecutionsCount + 1
+    )
     expect(mainCtrl.continuousUpdates.accountStateLatestInterval.restart).toHaveBeenCalledTimes(2)
     expect(mainCtrl.continuousUpdates.accountStatePendingInterval.stop).toHaveBeenCalledTimes(1)
   })
 
   test('should run fastAccountStateReFetchTimeout', async () => {
     const { mainCtrl } = await prepareTest()
     await waitForContinuousUpdatesCtrlReady(mainCtrl)
+    await waitForAccountStatesInitialLoad(mainCtrl)
 
+    const providersForTesting = ['1', '137']
+    const mockedProviders = filterProviders(mainCtrl.providers.providers, providersForTesting)
+    // ensure there is at least one provider that is not working
+    mockedProviders[1].isWorking = false
+    mockedProviders[137].isWorking = true
+    mainCtrl.providers.providers = mockedProviders
     jest.spyOn(mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout, 'start')
-    jest.spyOn(mainCtrl.continuousUpdates, 'updateAccountStateLatest')
-    jest.spyOn(mainCtrl.continuousUpdates, 'updateAccountStatePending')
-
-    const fastAccountStateReFetchMock = jest.spyOn(
-      mainCtrl.continuousUpdates,
-      'fastAccountStateReFetch'
-    )
+    mainCtrl.continuousUpdates.accountStateLatestInterval.start = jest
+      .fn()
+      .mockResolvedValue(undefined)
+    mainCtrl.continuousUpdates.accountStateLatestInterval.restart = jest
+      .fn()
+      .mockResolvedValue(undefined)
+    mainCtrl.continuousUpdates.accountStatePendingInterval.start = jest
+      .fn()
+      .mockResolvedValue(undefined)
+    mainCtrl.continuousUpdates.accountStatePendingInterval.restart = jest
+      .fn()
+      .mockResolvedValue(undefined)
 
+    // ensure there is at least one provider that is not working
+    mainCtrl.providers.providers[1].isWorking = false
+    mainCtrl.providers.providers[137].isWorking = true
     mainCtrl.ui.addView({ id: '1', type: 'popup', currentRoute: 'dashboard', isReady: true })
-    await jest.advanceTimersByTimeAsync(0)
+    const initialFnExecutionsCount =
+      mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout.fnExecutionsCount
     expect(mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout.start).toHaveBeenCalledTimes(1)
-    expect(fastAccountStateReFetchMock).toHaveBeenCalledTimes(0)
-    // ensure there is at least one provider that is not working
-    if (Object.values(mainCtrl.providers.providers).some((p) => !p.isWorking)) {
-      mainCtrl.providers.providers[1].isWorking = false
-    }
+    expect(mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout.fnExecutionsCount).toBe(
+      initialFnExecutionsCount
+    )
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout)
-    expect(fastAccountStateReFetchMock).toHaveBeenCalledTimes(1)
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+
+    expect(mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 1
+    )
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+    // @ts-ignore
+    mainCtrl.providers.emitUpdate()
+
     await waitForFnToBeCalledAndExecuted(mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout)
-    expect(fastAccountStateReFetchMock).toHaveBeenCalledTimes(2)
+    expect(mainCtrl.continuousUpdates.fastAccountStateReFetchTimeout.fnExecutionsCount).toBe(
+      initialFnExecutionsCount + 2
+    )
   })
 })