test: fix

packages/backend/src/nest/connections-manager/connections-manager.service.spec.ts

@@ -18,6 +18,7 @@ import { RegistrationService } from '../registration/registration.service'
 import { SocketModule } from '../socket/socket.module'
 import { ConnectionsManagerModule } from './connections-manager.module'
 import { ConnectionsManagerService } from './connections-manager.service'
+import { createLibp2pAddress } from '@quiet/common'
 
 describe('ConnectionsManagerService', () => {
   let module: TestingModule
@@ -101,7 +102,12 @@ describe('ConnectionsManagerService', () => {
         key: userIdentity.userCsr?.userKey,
         CA: [communityRootCa],
       },
-      peers: community.peerList,
+      peers: [
+        createLibp2pAddress(
+          'y7yczmugl2tekami7sbdz5pfaemvx7bahwthrdvcbzw5vex2crsr26qd',
+          'QmZoiJNAvCffeEHBjk766nLuKVdkxkAT7wfFJDPPLsbKSE'
+        ),
+      ],
     }
 
     await localDbService.put(LocalDBKeys.COMMUNITY, launchCommunityPayload)
@@ -113,41 +119,6 @@ describe('ConnectionsManagerService', () => {
     expect(launchCommunitySpy).toHaveBeenCalledWith(launchCommunityPayload)
   })
 
-  it('launches community on init if their data exists in local db', async () => {
-    const launchCommunityPayload: InitCommunityPayload = {
-      id: community.id,
-      peerId: userIdentity.peerId,
-      hiddenService: userIdentity.hiddenService,
-      certs: {
-        // @ts-expect-error
-        certificate: userIdentity.userCertificate,
-        // @ts-expect-error
-        key: userIdentity.userCsr?.userKey,
-        CA: [communityRootCa],
-      },
-      peers: community.peerList,
-    }
-
-    await localDbService.put(LocalDBKeys.COMMUNITY, launchCommunityPayload)
-
-    const peerAddress = '/dns4/test.onion/tcp/80/ws/p2p/peerid'
-    await localDbService.put(LocalDBKeys.PEERS, {
-      [peerAddress]: {
-        peerId: 'QmaEvCkpUG7GxhgvMkk8wxurfi1ehjHhSUNRksWTmXN2ix',
-        connectionTime: 50,
-        lastSeen: 1000,
-      },
-    })
-
-    await connectionsManagerService.closeAllServices()
-
-    const launchCommunitySpy = jest.spyOn(connectionsManagerService, 'launchCommunity').mockResolvedValue()
-
-    await connectionsManagerService.init()
-
-    expect(launchCommunitySpy).toHaveBeenCalledWith(Object.assign(launchCommunityPayload, { peers: [peerAddress] }))
-  })
-
   it('does not launch community on init if its data does not exist in local db', async () => {
     await connectionsManagerService.closeAllServices()
     await connectionsManagerService.init()
@@ -200,10 +171,10 @@ describe('ConnectionsManagerService', () => {
     // await connectionsManager.init()
     await localDbService.put(LocalDBKeys.COMMUNITY, launchCommunityPayload)
 
-    const peerAddress = '/dns4/test.onion/tcp/80/ws/p2p/peerid'
+    const peerid = 'QmaEvCkpUG7GxhgvMkk8wxurfi1ehjHhSUNRksWTmXN2ix'
     await localDbService.put(LocalDBKeys.PEERS, {
-      [peerAddress]: {
-        peerId: 'QmaEvCkpUG7GxhgvMkk8wxurfi1ehjHhSUNRksWTmXN2ix',
+      [peerid]: {
+        peerId: peerid,
         connectionTime: 50,
         lastSeen: 1000,
       },

packages/backend/src/nest/libp2p/process-in-chunks.service.ts

@@ -17,6 +17,7 @@ export class ProcessInChunksService<T> extends EventEmitter {
     this.data = data
     this.processItem = processItem
     this.chunkSize = chunkSize
+    // this.isActive = true
   }
 
   updateData(items: T[]) {
@@ -25,7 +26,7 @@ export class ProcessInChunksService<T> extends EventEmitter {
   }
 
   public async processOneItem() {
-    if (!this.isActive) return
+    // if (!this.isActive) return
     const toProcess = this.data.shift()
     if (toProcess) {
       try {
@@ -41,8 +42,8 @@ export class ProcessInChunksService<T> extends EventEmitter {
   }
 
   public async process() {
-    this.isActive = true
-    this.logger(`Processing ${Math.min(this.chunkSize, this.data.length)} items`)
+    // this.isActive = true
+    this.logger(`Processing ${this.data.length} items`)
     for (let i = 0; i < this.chunkSize; i++) {
       // Do not wait for this promise as items should be processed simultineously
       void this.processOneItem()

packages/backend/src/nest/libp2p/process-in-chunks.spec.ts

@@ -1,21 +1,70 @@
 import { jest, describe, it, expect } from '@jest/globals'
 import { ProcessInChunksService } from './process-in-chunks.service'
-
+import waitForExpect from 'wait-for-expect'
+import { TestModule } from '../common/test.module'
+import { Test, TestingModule } from '@nestjs/testing'
 describe('ProcessInChunks', () => {
+  let module: TestingModule
+  let processInChunks: ProcessInChunksService<string>
+
+  beforeEach(async () => {
+    module = await Test.createTestingModule({
+      imports: [TestModule, ProcessInChunksService],
+    }).compile()
+
+    processInChunks = await module.resolve(ProcessInChunksService)
+  })
+
   it('processes data', async () => {
     const mockProcessItem = jest
-      .fn(async () => {})
+      .fn(async a => {
+        console.log('processing', a)
+      })
       .mockResolvedValueOnce()
       .mockRejectedValueOnce(new Error('Rejected 1'))
       .mockResolvedValueOnce()
       .mockRejectedValueOnce(new Error('Rejected 2'))
-    const processInChunks = new ProcessInChunksService()
     processInChunks.init(['a', 'b', 'c', 'd'], mockProcessItem)
     await processInChunks.process()
-    expect(mockProcessItem).toBeCalledTimes(4)
+    await waitForExpect(() => {
+      expect(mockProcessItem).toBeCalledTimes(4)
+    })
+  })
+
+  it('processes new data', async () => {
+    const mockProcessItem = jest
+      .fn(async a => {
+        console.log('processing', a)
+      })
+      .mockResolvedValueOnce()
+      .mockRejectedValueOnce(new Error('Rejected 1'))
+    processInChunks.init(['a', 'b'], mockProcessItem)
+    await processInChunks.process()
+    processInChunks.updateData(['e', 'f'])
+    await processInChunks.process()
+    await waitForExpect(() => {
+      expect(mockProcessItem).toBeCalledTimes(4)
+    })
+  })
+
+  it('processes data in chunks', async () => {
+    const mockProcessItem = jest
+      .fn(async a => {
+        console.log('processing', a)
+      })
+      .mockResolvedValueOnce()
+      .mockRejectedValueOnce(new Error('Rejected 1'))
+      .mockResolvedValueOnce()
+      .mockRejectedValueOnce(new Error('Rejected 2'))
+    const chunkSize = 2
+    processInChunks.init(['a', 'b', 'c', 'd'], mockProcessItem, chunkSize)
+    await processInChunks.process()
+    await waitForExpect(() => {
+      expect(mockProcessItem).toBeCalledTimes(4)
+    })
   })
 
-  it('does not process more data if stopped', async () => {
+  it.skip('does not process more data if stopped', async () => {
     const mockProcessItem = jest.fn(async () => {})
     const processInChunks = new ProcessInChunksService()
     processInChunks.init(['a', 'b', 'c', 'd'], mockProcessItem)

packages/backend/src/nest/local-db/local-db.service.spec.ts

@@ -4,14 +4,12 @@ import { TestModule } from '../common/test.module'
 import { LocalDbModule } from './local-db.module'
 import { LocalDbService } from './local-db.service'
 import { LocalDBKeys } from './local-db.types'
+import { createLibp2pAddress } from '@quiet/common'
 
 describe('LocalDbService', () => {
   let module: TestingModule
   let localDbService: LocalDbService
-
-  let peer1Address: string
   let peer1Stats: Record<string, NetworkStats> = {}
-  let peer2Address: string
   let peer2Stats: Record<string, NetworkStats> = {}
 
   beforeAll(async () => {
@@ -21,19 +19,15 @@ describe('LocalDbService', () => {
 
     localDbService = await module.resolve(LocalDbService)
 
-    peer1Address =
-      '/dns4/mxtsfs4kzxzuisrw4tumdmycbyerqwakx37kj6om6azcjdaasifxmoqd.onion/tcp/443/wss/p2p/QmaEvCkpUG7GxhgvMkk8wxurfi1ehjHhSUNRksWTmXN2ix'
     peer1Stats = {
-      [peer1Address]: {
+      ['QmaEvCkpUG7GxhgvMkk8wxurfi1ehjHhSUNRksWTmXN2ix']: {
         peerId: 'QmaEvCkpUG7GxhgvMkk8wxurfi1ehjHhSUNRksWTmXN2ix',
         connectionTime: 50,
         lastSeen: 1000,
       },
     }
-    peer2Address =
-      '/dns4/hxr74a76b4lerhov75a6ha6yprruvow3wfu4qmmeoc6ajs7m7323lyid.onion/tcp/443/wss/p2p/QmZB6pVafcvAQfy5R5LxvDXvB8xcDifD39Lp3XGDM9XDuQ'
     peer2Stats = {
-      [peer2Address]: {
+      ['QmZB6pVafcvAQfy5R5LxvDXvB8xcDifD39Lp3XGDM9XDuQ']: {
         peerId: 'QmZB6pVafcvAQfy5R5LxvDXvB8xcDifD39Lp3XGDM9XDuQ',
         connectionTime: 500,
         lastSeen: 500,
@@ -71,16 +65,28 @@ describe('LocalDbService', () => {
     expect(localDbService.getStatus()).toEqual('closed')
   })
 
+  it('get sorted peers returns peers list if no stats in db', async () => {
+    const peers = [
+      createLibp2pAddress(
+        'zl37gnntp64dhnisddftypxbt5cqx6cum65vdv6oeaffrbqmemwc52ad.onion',
+        'QmPGdGDUV1PXaJky4V53KSvFszdqEcM7KCoDpF2uFPf5w6'
+      ),
+    ]
+    const sortedPeers = await localDbService.getSortedPeers(peers)
+    expect(sortedPeers).toEqual(peers)
+  })
+
   it('get sorted peers', async () => {
-    const extraPeers = [
-      '/dns4/zl37gnntp64dhnisddftypxbt5cqx6cum65vdv6oeaffrbqmemwc52ad.onion/tcp/443/ws/p2p/QmPGdGDUV1PXaJky4V53KSvFszdqEcM7KCoDpF2uFPf5w6',
+    const peers = [
+      createLibp2pAddress('nqnw4kc4c77fb47lk52m5l57h4tcxceo7ymxekfn7yh5m66t4jv2olad.onion', Object.keys(peer2Stats)[0]),
+      createLibp2pAddress('zl37gnntp64dhnisddftypxbt5cqx6cum65vdv6oeaffrbqmemwc52ad.onion', Object.keys(peer1Stats)[0]),
     ]
     await localDbService.put(LocalDBKeys.PEERS, {
       ...peer1Stats,
       ...peer2Stats,
     })
-    const sortedPeers = await localDbService.getSortedPeers(extraPeers)
-    expect(sortedPeers).toEqual([peer1Address, peer2Address, extraPeers[0]])
+    const sortedPeers = await localDbService.getSortedPeers(peers.reverse())
+    expect(sortedPeers).toEqual(peers)
   })
 
   it('updates nested object', async () => {
@@ -100,13 +106,13 @@ describe('LocalDbService', () => {
     }
 
     await localDbService.update(LocalDBKeys.PEERS, {
-      [peer2Address]: peer2StatsUpdated,
+      [peer2StatsUpdated.peerId]: peer2StatsUpdated,
     })
 
     const updatedPeersDBdata = await localDbService.get(LocalDBKeys.PEERS)
     expect(updatedPeersDBdata).toEqual({
       ...peer1Stats,
-      [peer2Address]: peer2StatsUpdated,
+      [peer2StatsUpdated.peerId]: peer2StatsUpdated,
     })
   })
 })

packages/backend/src/nest/local-db/local-db.service.ts

@@ -72,6 +72,7 @@ export class LocalDbService {
   }
 
   public async getSortedPeers(peers: string[] = []): Promise<string[]> {
+    console.log('getSortedPeers peers got', peers)
     const peersStats = (await this.get(LocalDBKeys.PEERS)) || {}
     const stats: NetworkStats[] = Object.values(peersStats)
     return sortPeers(peers, stats)

packages/common/src/sortPeers.ts

@@ -10,7 +10,7 @@ This is the very simple algorithm for evaluating the most wanted peers.
  */
 export const sortPeers = (peersAddresses: string[], stats: NetworkStats[]): string[] => {
   peersAddresses = peersAddresses.filter(add =>
-    add.match(/^\/dns4\/[a-z0-9]{56}.onion\/tcp\/80\/ws\/p2p\/[a-zA-Z0-9]{46}$/g)
+    add.match(/^\/dns4\/[a-z0-9]{56}.onion\/tcp\/(443|80)\/ws\/p2p\/[a-zA-Z0-9]{46}$/g)
   )
   const lastSeenSorted = [...stats].sort((a, b) => {
     return b.lastSeen - a.lastSeen

packages/desktop/package.json

@@ -111,7 +111,7 @@
     "build:renderer:prod": "webpack --config webpack/webpack.config.renderer.prod.js",
     "postBuild": "node scripts/postBuild.js",
     "prestart": "npm run build:main",
-    "start": "cross-env DEBUG='backend*,quiet*,state-manager*,desktop*,utils*,libp2p:websockets:listener:backend' npm run start:renderer",
+    "start": "cross-env DEBUG='backend*,quiet*,state-manager*,desktop*,utils*,libp2p:websockets:listener:backend,libp2p:connection-manager:auto-dialler' npm run start:renderer",
     "start:main": "cross-env NODE_ENV=development electron .",
     "start:renderer": "cross-env NODE_ENV=development webpack-dev-server --config webpack/webpack.config.renderer.dev.js",
     "storybook": "export NODE_OPTIONS=--openssl-legacy-provider && start-storybook -p 6006",