@ethersphere/bee-js 1.2.1 → 3.0.0

package/test/integration/modules/debug/connectivity.spec.ts

@@ -1,69 +0,0 @@
-import {
-  getPeers,
-  getBlocklist,
-  getTopology,
-  getNodeAddresses,
-  pingPeer,
-} from '../../../../src/modules/debug/connectivity'
-import { beeDebugUrl } from '../../../utils'
-
-describe('modules/debug/connectivity', () => {
-  test('getPeers', async () => {
-    const peers = await getPeers(beeDebugUrl())
-
-    expect(Array.isArray(peers)).toBeTruthy()
-    expect(peers.length).toBeGreaterThan(0)
-
-    peers.forEach(peer => {
-      expect(peer).toHaveProperty('address')
-      expect(peer.address).toMatch(/^[0-9a-f]{64}$/i)
-    })
-  })
-
-  test('getBlocklist', async () => {
-    const peers = await getBlocklist(beeDebugUrl())
-
-    expect(Array.isArray(peers)).toBeTruthy()
-
-    peers.forEach(peer => {
-      expect(peer).toHaveProperty('address')
-      expect(peer.address).toMatch(/^[0-9a-f]{64}$/i)
-    })
-  })
-
-  test('getTopology', async () => {
-    const topology = await getTopology(beeDebugUrl())
-
-    expect(topology.baseAddr).toMatch(/^[0-9a-f]{64}$/i)
-    expect(topology.population).toBeGreaterThanOrEqual(0)
-    expect(topology.connected).toBeGreaterThanOrEqual(0)
-    expect(Date.parse(topology.timestamp) !== NaN).toBeTruthy()
-    expect(topology.nnLowWatermark).toBeGreaterThanOrEqual(0)
-    expect(topology.depth).toBeGreaterThanOrEqual(0)
-
-    for (let i = 0; i < 16; ++i) {
-      const bin = topology.bins[`bin_${i}` as keyof typeof topology.bins]
-      expect(bin.population).toBeGreaterThanOrEqual(0)
-      expect(bin.connected).toBeGreaterThanOrEqual(0)
-      expect(Array.isArray(bin.disconnectedPeers) || bin.disconnectedPeers === null).toBeTruthy()
-      expect(Array.isArray(bin.connectedPeers) || bin.connectedPeers === null).toBeTruthy()
-    }
-  })
-
-  test('getNodeAddresses', async () => {
-    const addresses = await getNodeAddresses(beeDebugUrl())
-
-    expect(addresses.overlay).toMatch(/^[0-9a-f]{64}$/)
-    expect(Array.isArray(addresses.underlay)).toBeTruthy()
-    expect(addresses.ethereum).toMatch(/^0x[0-9a-f]{40}$/)
-    expect(addresses.publicKey).toMatch(/^[0-9a-f]{66}$/)
-    expect(addresses.pssPublicKey).toMatch(/^[0-9a-f]{66}$/)
-  })
-
-  test('pingPeer', async () => {
-    const peers = await getPeers(beeDebugUrl())
-    const res = await pingPeer(beeDebugUrl(), peers[0].address)
-
-    expect(res.rtt).toMatch(/^\d+(\.\d+)[mnpµ]?s$/)
-  })
-})

package/test/integration/modules/debug/settlements.spec.ts

@@ -1,34 +0,0 @@
-import * as settlements from '../../../../src/modules/debug/settlements'
-import { beeDebugUrl, commonMatchers } from '../../../utils'
-
-commonMatchers()
-
-describe('settlements', () => {
-  test('all settlements', async () => {
-    const response = await settlements.getAllSettlements(beeDebugUrl())
-
-    expect(response.totalReceived).toBeNumberString()
-    expect(response.totalSent).toBeNumberString()
-    expect(Array.isArray(response.settlements)).toBeTruthy()
-
-    if (response.settlements.length > 0) {
-      expect(response.settlements).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            peer: expect.any(String),
-            received: expect.any(String),
-            sent: expect.any(String),
-          }),
-        ]),
-      )
-
-      const peerSettlement = response.settlements[0]
-
-      const peerSettlementResponse = await settlements.getSettlements(beeDebugUrl(), peerSettlement.peer)
-
-      expect(peerSettlementResponse.peer).toEqual(peerSettlement.peer)
-      expect(peerSettlementResponse.received).toBeNumberString()
-      expect(peerSettlementResponse.sent).toBeNumberString()
-    }
-  })
-})

package/test/integration/modules/debug/states.spec.ts

@@ -1,34 +0,0 @@
-import { beeDebugUrl, commonMatchers } from '../../../utils'
-import * as states from '../../../../src/modules/debug/states'
-
-const BEE_DEBUG_URL = beeDebugUrl()
-commonMatchers()
-
-describe('modules/states', () => {
-  describe('chainstate', () => {
-    it('should fetch the chainstate', async () => {
-      const state = await states.getChainState(BEE_DEBUG_URL)
-
-      expect(state).toHaveProperty('block')
-      expect(state).toHaveProperty('totalAmount')
-      expect(state).toHaveProperty('currentPrice')
-      expect(state.block).toBeNumberString()
-      expect(state.totalAmount).toBeNumberString()
-      expect(state.currentPrice).toBeNumberString()
-    })
-  })
-  describe('ReserveState', () => {
-    it('should fetch the reserve state', async () => {
-      const state = await states.getReserveState(BEE_DEBUG_URL)
-
-      expect(state).toHaveProperty('radius')
-      expect(state).toHaveProperty('available')
-      expect(state).toHaveProperty('outer')
-      expect(state).toHaveProperty('inner')
-      expect(state.radius).toBeType('number')
-      expect(state.available).toBeType('number')
-      expect(state.outer).toBeNumberString()
-      expect(state.inner).toBeNumberString()
-    })
-  })
-})

package/test/integration/modules/debug/status.spec.ts

@@ -1,65 +0,0 @@
-import { engines } from '../../../../package.json'
-import {
-  getHealth,
-  isSupportedVersion,
-  SUPPORTED_BEE_VERSION,
-  SUPPORTED_BEE_VERSION_EXACT,
-} from '../../../../src/modules/debug/status'
-import { beeDebugUrl } from '../../../utils'
-
-/**
- * Matches these:
- * 0.5.3-c423a39c, 0.5.3-c423a39c-dirty, 0.5.3, 1.0.0-rc4, 1.0.0-rc4-02dd4346
- */
-const expectValidVersion = (string: string): void => {
-  const parts = string.split('-')
-  expect(parts.length).toBeGreaterThanOrEqual(1)
-  expect(parts.length).toBeLessThanOrEqual(3)
-  expect(parts[0]).toMatch(/^\d+\.\d+\.\d+$/)
-
-  if (parts[1]) {
-    if (parts[1].startsWith('rc')) {
-      expect(parts[1]).toMatch(/^rc\d+$/)
-
-      if (parts[2]) {
-        expect(parts[2]).toMatch(/^[0-9a-f]{7,8}$/)
-      }
-    } else {
-      expect(parts[1]).toMatch(/^[0-9a-f]{7,8}$/)
-
-      if (parts[2]) {
-        expect(parts[2]).toBe('dirty')
-      }
-    }
-  }
-}
-
-const BEE_DEBUG_URL = beeDebugUrl()
-
-describe('modules/status', () => {
-  test('getHealth', async () => {
-    const health = await getHealth(BEE_DEBUG_URL)
-
-    expect(health.status).toBe('ok')
-    // Matches both versions like 0.5.3-c423a39c, 0.5.3-c423a39c-dirty and 0.5.3
-    expectValidVersion(health.version)
-  })
-
-  test('isSupportedVersion', async () => {
-    const isSupported = await isSupportedVersion(BEE_DEBUG_URL)
-
-    expect(isSupported).toBe(true)
-  })
-
-  test('format of supported bee version', () => {
-    // Matches semantic version e.g. 0.5.3
-    expect(SUPPORTED_BEE_VERSION).toMatch(/^\d+\.\d+\.\d+$/i)
-
-    // Matches semantic version with commit message e.g. 0.5.3-acbd0e2
-    expectValidVersion(SUPPORTED_BEE_VERSION_EXACT)
-  })
-
-  test('SUPPORTED_BEE_VERSION_EXACT should come from package.json', () => {
-    expect(SUPPORTED_BEE_VERSION_EXACT).toBe(engines.bee)
-  })
-})

package/test/integration/modules/debug/tag.spec.ts

@@ -1,27 +0,0 @@
-import * as beeTag from '../../../../src/modules/tag'
-import * as beeDebugTag from '../../../../src/modules/debug/tag'
-import { beeDebugUrl, beeUrl } from '../../../utils'
-
-const BEE_URL = beeUrl()
-const BEE_DEBUG_URL = beeDebugUrl()
-
-describe('modules/tag', () => {
-  it('should retrieve extended tag', async () => {
-    const tag1 = await beeTag.createTag(BEE_URL)
-    const tag2 = await beeDebugTag.retrieveExtendedTag(BEE_DEBUG_URL, tag1.uid)
-
-    expect(tag2).toEqual(
-      expect.objectContaining({
-        total: expect.any(Number),
-        split: expect.any(Number),
-        seen: expect.any(Number),
-        stored: expect.any(Number),
-        sent: expect.any(Number),
-        synced: expect.any(Number),
-        uid: expect.any(Number),
-        startedAt: expect.any(String),
-        address: expect.any(String),
-      }),
-    )
-  })
-})

package/test/integration/modules/feed.spec.ts

@@ -1,61 +0,0 @@
-import { createFeedManifest, fetchFeedUpdate } from '../../../src/modules/feed'
-import { HexString, hexToBytes, makeHexString } from '../../../src/utils/hex'
-import {
-  beeUrl,
-  commonMatchers,
-  ERR_TIMEOUT,
-  getPostageBatch,
-  testIdentity,
-  tryDeleteChunkFromLocalStorage,
-} from '../../utils'
-import { upload as uploadSOC } from '../../../src/modules/soc'
-import type { Topic } from '../../../src/types'
-
-commonMatchers()
-
-describe('modules/feed', () => {
-  const url = beeUrl()
-  const owner = makeHexString(testIdentity.address, 40)
-  const topic = '0000000000000000000000000000000000000000000000000000000000000000' as Topic
-
-  test('feed manifest creation', async () => {
-    const reference = '92442c3e08a308aeba8e2d231733ec57011a203354cad24129e7e0c37bac0cbe'
-    const response = await createFeedManifest(url, owner, topic, getPostageBatch())
-
-    expect(response).toEqual(reference)
-  })
-
-  test(
-    'empty feed update',
-    async () => {
-      const emptyTopic = '1000000000000000000000000000000000000000000000000000000000000000' as Topic
-      const feedUpdate = fetchFeedUpdate(url, owner, emptyTopic)
-
-      await expect(feedUpdate).rejects.toThrow('Not Found')
-    },
-    ERR_TIMEOUT,
-  )
-
-  test('one feed update', async () => {
-    const oneUpdateTopic = '2000000000000000000000000000000000000000000000000000000000000000' as Topic
-    const identifier = '7c5c4c857ed4cae434c2c737bad58a93719f9b678647310ffd03a20862246a3b'
-    const signature =
-      'bba40ea2c87b7801f54f5cca70e06deaed5c366b588e38ce0c42f7f8f16562c3243b43101faa6dbaeaab3244b1a0ceaec92dd117995e19116a372eadbec945b01b'
-    const socData = hexToBytes(
-      '280000000000000000000000602a57df0000000000000000000000000000000000000000000000000000000000000000' as HexString,
-    )
-
-    // delete the chunk from local storage if already exists
-    // this makes the test repeatable
-    const cacAddress = '03e8eef6d72dbca9dfb7d2e15a5a305a152a3807ac7fd5ea52721a16972f3813'
-    await tryDeleteChunkFromLocalStorage(cacAddress)
-
-    const socResponse = await uploadSOC(url, owner, identifier, signature, socData, getPostageBatch())
-    expect(socResponse).toBeType('string')
-
-    const feedUpdate = await fetchFeedUpdate(url, owner, oneUpdateTopic)
-    expect(feedUpdate.reference).toBeType('string')
-    expect(feedUpdate.feedIndex).toEqual('0000000000000000')
-    expect(feedUpdate.feedIndexNext).toEqual('0000000000000001')
-  }, 21000)
-})

package/test/integration/modules/pinning.spec.ts

@@ -1,155 +0,0 @@
-import * as pinning from '../../../src/modules/pinning'
-import * as bzz from '../../../src/modules/bzz'
-import * as bytes from '../../../src/modules/bytes'
-import * as chunk from '../../../src/modules/chunk'
-import {
-  beeUrl,
-  invalidReference,
-  randomByteArray,
-  testChunkData,
-  testChunkHash,
-  ERR_TIMEOUT,
-  getPostageBatch,
-  commonMatchers,
-} from '../../utils'
-import { Collection } from '../../../src/types'
-
-const BEE_URL = beeUrl()
-commonMatchers()
-
-describe('modules/pin', () => {
-  describe('should work with files', () => {
-    const randomData = randomByteArray(5000)
-
-    it('should pin an existing file', async () => {
-      const hash = await bzz.uploadFile(BEE_URL, randomData, getPostageBatch())
-      await pinning.pin(BEE_URL, hash)
-    })
-
-    it('should unpin an existing file', async () => {
-      const hash = await bzz.uploadFile(BEE_URL, randomData, getPostageBatch())
-      await pinning.unpin(BEE_URL, hash)
-    })
-
-    it(
-      'should not pin a non-existing file',
-      async () => {
-        await expect(pinning.pin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing file', async () => {
-      await expect(pinning.unpin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-    })
-  })
-
-  describe('should work with collections', () => {
-    const testCollection: Collection<Uint8Array> = [
-      {
-        path: '0',
-        data: Uint8Array.from([0]),
-      },
-      {
-        path: '1',
-        data: Uint8Array.from([1]),
-      },
-    ]
-
-    it('should pin an existing collection', async () => {
-      const hash = await bzz.uploadCollection(BEE_URL, testCollection, getPostageBatch())
-      await pinning.pin(BEE_URL, hash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it('should unpin an existing collections', async () => {
-      const hash = await bzz.uploadCollection(BEE_URL, testCollection, getPostageBatch())
-      await pinning.unpin(BEE_URL, hash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it(
-      'should not pin a non-existing collections',
-      async () => {
-        await expect(pinning.pin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing collections', async () => {
-      await expect(pinning.unpin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-    })
-  })
-
-  describe('should work with data', () => {
-    const randomData = randomByteArray(5000)
-
-    it('should pin existing data', async () => {
-      const hash = await bytes.upload(BEE_URL, randomData, getPostageBatch())
-      await pinning.pin(BEE_URL, hash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it('should unpin existing data', async () => {
-      const hash = await bytes.upload(BEE_URL, randomData, getPostageBatch())
-      await pinning.pin(BEE_URL, hash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it(
-      'should not pin a non-existing data',
-      async () => {
-        await expect(pinning.pin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing data', async () => {
-      await expect(pinning.unpin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-    })
-  })
-
-  describe('should work with chunks', () => {
-    it('should pin existing chunk', async () => {
-      const chunkReference = await chunk.upload(BEE_URL, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.pin(BEE_URL, testChunkHash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it('should unpin existing chunk', async () => {
-      const chunkReference = await chunk.upload(BEE_URL, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.unpin(BEE_URL, testChunkHash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it(
-      'should not pin a non-existing chunk',
-      async () => {
-        await expect(pinning.pin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing chunk', async () => {
-      await expect(pinning.unpin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-    })
-
-    it('should return pinning status of existing chunk', async () => {
-      const chunkReference = await chunk.upload(BEE_URL, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.pin(BEE_URL, testChunkHash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-      const pinningStatus = await pinning.getPin(BEE_URL, testChunkHash)
-      expect(pinningStatus.reference).toEqual(testChunkHash)
-    })
-
-    it('should not return pinning status of non-existing chunk', async () => {
-      await expect(pinning.getPin(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-    })
-
-    it('should return list of pinned chunks', async () => {
-      const chunkReference = await chunk.upload(BEE_URL, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.pin(BEE_URL, testChunkHash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-  })
-})

package/test/integration/modules/pss.spec.ts

@@ -1,92 +0,0 @@
-import * as pss from '../../../src/modules/pss'
-import * as connectivity from '../../../src/modules/debug/connectivity'
-import { beeDebugUrl, beePeerDebugUrl, beePeerUrl, beeUrl, getPostageBatch, PSS_TIMEOUT } from '../../utils'
-
-const BEE_URL = beeUrl()
-const BEE_PEER_URL = beePeerUrl()
-const BEE_DEBUG_PEER_URL = beePeerDebugUrl()
-
-// these tests only work when there is at least one peer connected
-describe('modules/pss', () => {
-  it(
-    'should send PSS message',
-    async () => {
-      const topic = 'send-pss-message'
-      const message = 'hello'
-
-      const debugUrl = beeDebugUrl()
-      const peers = await connectivity.getPeers(debugUrl)
-      expect(peers.length).toBeGreaterThan(0)
-
-      const target = peers[0].address
-      await pss.send(BEE_URL, topic, target, message, getPostageBatch()) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    },
-    PSS_TIMEOUT,
-  )
-
-  it(
-    'should send and receive PSS message',
-    async () => {
-      return new Promise<void>((resolve, reject) => {
-        ;(async () => {
-          const topic = 'send-receive-pss-message'
-          const message = 'hello'
-
-          const ws = pss.subscribe(BEE_URL, topic)
-          ws.onmessage = ev => {
-            const receivedMessage = Buffer.from(ev.data as string).toString()
-
-            // ignore empty messages
-            if (receivedMessage.length === 0) {
-              return
-            }
-            ws.terminate()
-            expect(receivedMessage).toEqual(message)
-            resolve()
-          }
-
-          const debugUrl = beeDebugUrl()
-
-          const addresses = await connectivity.getNodeAddresses(debugUrl)
-          const target = addresses.overlay
-          await pss.send(BEE_PEER_URL, topic, target, message, getPostageBatch(BEE_DEBUG_PEER_URL))
-        })().catch(reject)
-      })
-    },
-    PSS_TIMEOUT,
-  )
-
-  it(
-    'should send and receive PSS message with public key',
-    async () => {
-      // Jest does not allow use `done` and return Promise so this wrapper work arounds that.
-      return new Promise<void>((resolve, reject) => {
-        ;(async () => {
-          const topic = 'send-receive-pss-public-key'
-          const message = 'hello'
-
-          const ws = pss.subscribe(BEE_URL, topic)
-          ws.onmessage = ev => {
-            const receivedMessage = Buffer.from(ev.data as string).toString()
-
-            // ignore empty messages
-            if (receivedMessage.length === 0) {
-              return
-            }
-            ws.terminate()
-            expect(receivedMessage).toEqual(message)
-            resolve()
-          }
-
-          const debugUrl = beeDebugUrl()
-
-          const addresses = await connectivity.getNodeAddresses(debugUrl)
-          const target = addresses.overlay
-          const recipient = addresses.pssPublicKey
-          await pss.send(BEE_PEER_URL, topic, target, message, getPostageBatch(BEE_DEBUG_PEER_URL), recipient)
-        })().catch(reject)
-      })
-    },
-    PSS_TIMEOUT,
-  )
-})

package/test/integration/modules/status.spec.ts

@@ -1,10 +0,0 @@
-import * as status from '../../../src/modules/status'
-import { beeUrl } from '../../utils'
-
-const BEE_URL = beeUrl()
-
-describe('checkConnection', () => {
-  test('should connect to a running node', async () => {
-    await status.checkConnection(BEE_URL)
-  })
-})

package/test/integration/modules/stewardship.spec.ts

@@ -1,32 +0,0 @@
-import * as bzz from '../../../src/modules/bzz'
-import * as stewardship from '../../../src/modules/stewardship'
-import { Collection } from '../../../src/types'
-import { beeUrl, getPostageBatch } from '../../utils'
-
-const BEE_URL = beeUrl()
-
-describe('modules/stewardship', () => {
-  describe('collections', () => {
-    it('should reupload directory', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch(), { pin: true })
-      await stewardship.reupload(BEE_URL, hash) // Does not return anything, but will throw error if something is wrong
-    })
-  })
-
-  describe('file', () => {
-    it('should reupload file', async () => {
-      const data = 'hello world'
-      const filename = 'hello.txt'
-
-      const hash = await bzz.uploadFile(BEE_URL, data, getPostageBatch(), filename, { pin: true })
-      await stewardship.reupload(BEE_URL, hash) // Does not return anything, but will throw error if something is wrong
-    })
-  })
-})

package/test/integration/modules/tag.spec.ts

@@ -1,51 +0,0 @@
-import * as tag from '../../../src/modules/tag'
-import { beeUrl, commonMatchers } from '../../utils'
-
-const BEE_URL = beeUrl()
-
-commonMatchers()
-
-describe('modules/tag', () => {
-  it('should list tags', async () => {
-    await tag.createTag(BEE_URL)
-    const tags = await tag.getAllTags(BEE_URL)
-
-    expect(tags).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          total: expect.any(Number),
-          processed: expect.any(Number),
-          synced: expect.any(Number),
-          uid: expect.any(Number),
-          startedAt: expect.any(String),
-        }),
-      ]),
-    )
-  })
-
-  it('should create empty tag', async () => {
-    const tag1 = await tag.createTag(BEE_URL)
-
-    expect(tag1.total).toBe(0)
-    expect(tag1.processed).toBe(0)
-    expect(tag1.synced).toBe(0)
-    expect(Number.isInteger(tag1.uid)).toBeTruthy()
-    expect(tag1.startedAt).toBeType('string')
-  })
-
-  it('should retrieve previously created empty tag', async () => {
-    const tag1 = await tag.createTag(BEE_URL)
-    const tag2 = await tag.retrieveTag(BEE_URL, tag1.uid)
-
-    expect(tag1).toEqual(tag2)
-    expect(tag1).toEqual(
-      expect.objectContaining({
-        total: expect.any(Number),
-        processed: expect.any(Number),
-        synced: expect.any(Number),
-        uid: expect.any(Number),
-        startedAt: expect.any(String),
-      }),
-    )
-  })
-})

package/test/test-type-sequencer.js

@@ -1,36 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const Sequencer = require('@jest/test-sequencer').default
-
-/**
- * Jest Sequencer that allows to specify order of execution of tests.
- * We are using it to first execute unit tests and then integration when
- * whole test suite is run.
- *
- * https://jestjs.io/docs/next/configuration#testsequencer-string
- */
-class TestTypeSequencer extends Sequencer {
-  order = ['unit', 'integration']
-
-  getType(test) {
-    for (const type of this.order) {
-      if (test.path.includes(type)) {
-        return type
-      }
-    }
-  }
-
-  sort(tests) {
-    // Test structure information
-    // https://github.com/facebook/jest/blob/6b8b1404a1d9254e7d5d90a8934087a9c9899dab/packages/jest-runner/src/types.ts#L17-L21
-    const copyTests = Array.from(tests)
-
-    return copyTests.sort((testA, testB) => {
-      const typeA = this.getType(testA)
-      const typeB = this.getType(testB)
-
-      return this.order.indexOf(typeA) - this.order.indexOf(typeB)
-    })
-  }
-}
-
-module.exports = TestTypeSequencer