@ethersphere/bee-js 1.2.1 → 3.0.0

package/test/integration/chunk/bmt.spec.ts

@@ -1,33 +0,0 @@
-import { bmtHash } from '../../../src/chunk/bmt'
-import { beeUrl, getPostageBatch, randomByteArray } from '../../utils'
-import * as chunk from '../../../src/modules/chunk'
-import { makeSpan } from '../../../src/chunk/span'
-import { bytesToHex } from '../../../src/utils/hex'
-
-describe('bmt', () => {
-  it('should produce the same hash as Bee', async () => {
-    /**
-     * We upload chunks smaller than 4096 bytes on the /bytes
-     * endpoint therefore it is stored in a single chunk.
-     */
-    for (let i = 1; i <= 4096; i *= 2) {
-      const payload = new Uint8Array(i)
-      const span = makeSpan(i)
-      const data = new Uint8Array([...span, ...payload])
-
-      const reference = bytesToHex(bmtHash(data))
-      const response = await chunk.upload(beeUrl(), data, getPostageBatch())
-      expect(response).toEqual(reference)
-    }
-  })
-
-  it('should produce the same hash as Bee for random content', async () => {
-    const payload = randomByteArray(4096)
-    const span = makeSpan(payload.length)
-    const data = new Uint8Array([...span, ...payload])
-
-    const reference = bytesToHex(bmtHash(data))
-    const response = await chunk.upload(beeUrl(), data, getPostageBatch())
-    expect(response).toEqual(reference)
-  })
-})

package/test/integration/chunk/cac.spec.ts

@@ -1,27 +0,0 @@
-import { assertBytes } from '../../../src/utils/bytes'
-import { makeContentAddressedChunk, assertValidChunkData } from '../../../src/chunk/cac'
-import { beeUrl, getPostageBatch } from '../../utils'
-import * as chunkAPI from '../../../src/modules/chunk'
-import { hexToBytes, bytesToHex } from '../../../src/utils/hex'
-
-describe('cac', () => {
-  const payload = new Uint8Array([1, 2, 3])
-  const contentHash = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338'
-
-  test('upload content address chunk', async () => {
-    const cac = makeContentAddressedChunk(payload)
-    const address = cac.address()
-    const reference = bytesToHex(address)
-    const response = await chunkAPI.upload(beeUrl(), cac.data, getPostageBatch())
-
-    expect(response).toEqual(reference)
-  })
-
-  test('download content address chunk', async () => {
-    const address = hexToBytes(contentHash)
-    assertBytes(address, 32)
-    const data = await chunkAPI.download(beeUrl(), contentHash)
-
-    expect(() => assertValidChunkData(data, address)).not.toThrow()
-  })
-})

package/test/integration/chunk/soc.spec.ts

@@ -1,38 +0,0 @@
-import { Bytes, assertBytes } from '../../../src/utils/bytes'
-import { makeSingleOwnerChunk, makeSingleOwnerChunkFromData, uploadSingleOwnerChunk } from '../../../src/chunk/soc'
-import { makeContentAddressedChunk } from '../../../src/chunk/cac'
-import { beeUrl, getPostageBatch, testIdentity, tryDeleteChunkFromLocalStorage } from '../../utils'
-import { makePrivateKeySigner } from '../../../src/chunk/signer'
-import * as chunkAPI from '../../../src/modules/chunk'
-import { HexString, hexToBytes, bytesToHex } from '../../../src/utils/hex'
-
-describe('soc', () => {
-  const privateKey = hexToBytes(testIdentity.privateKey)
-  assertBytes(privateKey, 32)
-  const signer = makePrivateKeySigner(privateKey)
-  const payload = new Uint8Array([1, 2, 3])
-  const socHash = '9d453ebb73b2fedaaf44ceddcf7a0aa37f3e3d6453fea5841c31f0ea6d61dc85' as HexString
-  const identifier = new Uint8Array(32) as Bytes<32>
-
-  test('upload single owner chunk', async () => {
-    const cac = makeContentAddressedChunk(payload)
-    const soc = await makeSingleOwnerChunk(cac, identifier, signer)
-    const socAddress = bytesToHex(soc.address())
-
-    await tryDeleteChunkFromLocalStorage(socHash)
-
-    const response = await uploadSingleOwnerChunk(beeUrl(), soc, getPostageBatch())
-
-    expect(response).toEqual(socAddress)
-  })
-
-  test('download single owner chunk', async () => {
-    const data = await chunkAPI.download(beeUrl(), socHash)
-    const address = hexToBytes(socHash)
-    assertBytes(address, 32)
-    const soc = makeSingleOwnerChunkFromData(data, address)
-    const socAddress = soc.address()
-
-    expect(socAddress).toEqual(address)
-  })
-})

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

@@ -1,84 +0,0 @@
-import { fetchFeedUpdate } from '../../../src/modules/feed'
-import { hexToBytes, makeHexString } from '../../../src/utils/hex'
-import { beeUrl, ERR_TIMEOUT, getPostageBatch, testIdentity } from '../../utils'
-import { ChunkReference, downloadFeedUpdate, findNextIndex, Index, uploadFeedUpdate } from '../../../src/feed'
-import { Bytes, assertBytes } from '../../../src/utils/bytes'
-import { makePrivateKeySigner } from '../../../src/chunk/signer'
-import { makeContentAddressedChunk } from '../../../src/chunk/cac'
-import * as chunkAPI from '../../../src/modules/chunk'
-import type { PrivateKeyBytes, Signer, Topic } from '../../../src/types'
-import { BeeResponseError } from '../../../src'
-
-function makeChunk(index: number) {
-  return makeContentAddressedChunk(new Uint8Array([index]))
-}
-
-async function uploadChunk(url: string, index: number): Promise<ChunkReference> {
-  const chunk = makeChunk(index)
-  const reference = await chunkAPI.upload(url, chunk.data, getPostageBatch())
-
-  return hexToBytes(reference) as ChunkReference
-}
-
-// FIXME helper function for setting up test state for testing finding feed updates
-// it is not intended as a replacement in tests for `uploadFeedUpdate`
-// https://github.com/ethersphere/bee-js/issues/154
-async function tryUploadFeedUpdate(url: string, signer: Signer, topic: Topic, index: Index, reference: ChunkReference) {
-  try {
-    await uploadFeedUpdate(url, signer, topic, index, reference, getPostageBatch())
-  } catch (e) {
-    if (e instanceof BeeResponseError && e.status === 409) {
-      // ignore conflict errors when uploading the same feed update twice
-      return
-    }
-    throw e
-  }
-}
-
-describe('feed', () => {
-  const url = beeUrl()
-  const owner = makeHexString(testIdentity.address, 40)
-  const signer = makePrivateKeySigner(hexToBytes(testIdentity.privateKey) as PrivateKeyBytes)
-  const topic = '0000000000000000000000000000000000000000000000000000000000000000' as Topic
-
-  test(
-    'empty feed update',
-    async () => {
-      const emptyTopic = '1000000000000000000000000000000000000000000000000000000000000000' as Topic
-      const index = await findNextIndex(url, owner, emptyTopic)
-
-      expect(index).toEqual('0000000000000000')
-    },
-    ERR_TIMEOUT,
-  )
-
-  test('feed update', async () => {
-    const uploadedChunk = await uploadChunk(url, 0)
-    await tryUploadFeedUpdate(url, signer, topic, 0, uploadedChunk)
-
-    const feedUpdate = await fetchFeedUpdate(url, owner, topic)
-
-    expect(feedUpdate.feedIndex).toEqual('0000000000000000')
-    expect(feedUpdate.feedIndexNext).toEqual('0000000000000001')
-  }, 21000)
-
-  test('multiple updates and lookup', async () => {
-    const reference = makeHexString('0000000000000000000000000000000000000000000000000000000000000000', 64)
-    const referenceBytes = hexToBytes(reference)
-    assertBytes(referenceBytes, 32)
-    const multipleUpdateTopic = '3000000000000000000000000000000000000000000000000000000000000000' as Topic
-
-    const numUpdates = 5
-
-    for (let i = 0; i < numUpdates; i++) {
-      const referenceI = new Uint8Array([i, ...referenceBytes.slice(1)]) as Bytes<32>
-      await tryUploadFeedUpdate(url, signer, multipleUpdateTopic, i, referenceI)
-    }
-
-    for (let i = 0; i < numUpdates; i++) {
-      const referenceI = new Uint8Array([i, ...referenceBytes.slice(1)]) as Bytes<32>
-      const feedUpdateResponse = await downloadFeedUpdate(url, signer.address, multipleUpdateTopic, i)
-      expect(feedUpdateResponse.reference).toEqual(referenceI)
-    }
-  }, 15000)
-})

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

@@ -1,23 +0,0 @@
-import * as bytes from '../../../src/modules/bytes'
-import { beeUrl, invalidReference, ERR_TIMEOUT, getPostageBatch } from '../../utils'
-
-const BEE_URL = beeUrl()
-
-describe('modules/bytes', () => {
-  it('should store and retrieve data', async () => {
-    const data = 'hello world'
-
-    const hash = await bytes.upload(BEE_URL, data, getPostageBatch())
-    const downloadedData = await bytes.download(BEE_URL, hash)
-
-    expect(Buffer.from(downloadedData).toString()).toEqual(data)
-  })
-
-  it(
-    'should catch error',
-    async () => {
-      await expect(bytes.download(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-    },
-    ERR_TIMEOUT,
-  )
-})

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

@@ -1,270 +0,0 @@
-import * as bzz from '../../../src/modules/bzz'
-import * as tag from '../../../src/modules/tag'
-import { Collection, ENCRYPTED_REFERENCE_HEX_LENGTH } from '../../../src/types'
-import { makeCollectionFromFS } from '../../../src/utils/collection'
-import { beeUrl, BIG_FILE_TIMEOUT, getPostageBatch, invalidReference, randomByteArray } from '../../utils'
-import { Readable } from 'stream'
-
-const BEE_URL = beeUrl()
-
-describe('modules/bzz', () => {
-  describe('collections', () => {
-    it('should store and retrieve collection with single file', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch())
-      const file = await bzz.downloadFile(BEE_URL, hash, directoryStructure[0].path)
-
-      expect(file.name).toEqual(directoryStructure[0].path)
-      expect(file.data).toEqual(directoryStructure[0].data)
-    })
-
-    it('should retrieve the filename but not the complete path', async () => {
-      const path = 'a/b/c/d/'
-      const name = '0'
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: `${path}${name}`,
-          data: Uint8Array.from([0]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch())
-      const file = await bzz.downloadFile(BEE_URL, hash, directoryStructure[0].path)
-
-      expect(file.name).toEqual(name)
-      expect(file.data).toEqual(directoryStructure[0].data)
-    })
-
-    it('should work with pinning', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch(), { pin: true })
-      const file = await bzz.downloadFile(BEE_URL, hash, directoryStructure[0].path)
-
-      expect(file.name).toEqual(directoryStructure[0].path)
-      expect(file.data).toEqual(directoryStructure[0].data)
-    })
-
-    it('should work with encryption', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch(), { encrypt: true })
-      const file = await bzz.downloadFile(BEE_URL, hash, directoryStructure[0].path)
-
-      expect(file.name).toEqual(directoryStructure[0].path)
-      expect(file.data).toEqual(directoryStructure[0].data)
-      expect(hash.length).toEqual(ENCRYPTED_REFERENCE_HEX_LENGTH)
-    })
-
-    it(
-      'should upload bigger file',
-      async () => {
-        const directoryStructure: Collection<Uint8Array> = [
-          {
-            path: '0',
-            data: new Uint8Array(32 * 1024 * 1024),
-          },
-        ]
-
-        const response = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch())
-
-        expect(typeof response).toEqual('string')
-      },
-      BIG_FILE_TIMEOUT,
-    )
-
-    it('should throw error when the upload url is not set', async () => {
-      await expect(
-        bzz.uploadCollection(undefined as unknown as string, undefined as unknown as [], getPostageBatch()),
-      ).rejects.toThrowError()
-    })
-
-    it('should throw error when the upload url is not empty', async () => {
-      const url = ''
-      await expect(bzz.uploadCollection(url, undefined as unknown as [], getPostageBatch())).rejects.toThrowError()
-    })
-
-    it('should throw error when the collection is empty', async () => {
-      await expect(bzz.uploadCollection(BEE_URL, [], getPostageBatch())).rejects.toThrowError()
-    })
-
-    it('should store and retrieve collection', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-        {
-          path: '1',
-          data: Uint8Array.from([1]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch())
-
-      const file0 = await bzz.downloadFile(BEE_URL, hash, directoryStructure[0].path)
-      expect(file0.name).toEqual(directoryStructure[0].path)
-      expect(file0.data).toEqual(directoryStructure[0].data)
-
-      const file1 = await bzz.downloadFile(BEE_URL, hash, directoryStructure[1].path)
-      expect(file1.name).toEqual(directoryStructure[1].path)
-      expect(file1.data).toEqual(directoryStructure[1].data)
-    })
-
-    it('should store and retrieve collection with index document', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-        {
-          path: '1',
-          data: Uint8Array.from([1]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch(), {
-        indexDocument: '0',
-      })
-
-      const indexFile = await bzz.downloadFile(BEE_URL, hash)
-      expect(indexFile.name).toEqual(directoryStructure[0].path)
-      expect(indexFile.data).toEqual(directoryStructure[0].data)
-    })
-
-    it('should store and retrieve collection with error document', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-        {
-          path: '1',
-          data: Uint8Array.from([1]),
-        },
-      ]
-
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch(), {
-        errorDocument: '0',
-      })
-
-      const errorFile = await bzz.downloadFile(BEE_URL, hash, 'error')
-      expect(errorFile.name).toEqual(directoryStructure[0].path)
-      expect(errorFile.data).toEqual(directoryStructure[0].data)
-    })
-
-    it('should store and retrieve actual directory', async () => {
-      const path = 'test/data/'
-      const dir = `./${path}`
-      const file3Name = '3.txt'
-      const subDir = 'sub/'
-      const data = Uint8Array.from([51, 10])
-      const directoryStructure = await makeCollectionFromFS(dir)
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch())
-
-      const file3 = await bzz.downloadFile(BEE_URL, hash, `${subDir}${file3Name}`)
-      expect(file3.name).toEqual(file3Name)
-      expect(file3.data).toEqual(data)
-    })
-
-    it('should store and retrieve actual directory with index document', async () => {
-      const path = 'test/data/'
-      const dir = `./${path}`
-      const fileName = '1.txt'
-      const data = Uint8Array.from([49, 10])
-      const directoryStructure = await makeCollectionFromFS(dir)
-      const hash = await bzz.uploadCollection(BEE_URL, directoryStructure, getPostageBatch(), {
-        indexDocument: `${fileName}`,
-      })
-
-      const file1 = await bzz.downloadFile(BEE_URL, hash)
-      expect(file1.name).toEqual(fileName)
-      expect(file1.data).toEqual(data)
-    })
-  })
-
-  describe('file', () => {
-    it('should store and retrieve file', async () => {
-      const data = 'hello world'
-      const filename = 'hello.txt'
-
-      const hash = await bzz.uploadFile(BEE_URL, data, getPostageBatch(), filename)
-      const fileData = await bzz.downloadFile(BEE_URL, hash)
-
-      expect(Buffer.from(fileData.data).toString()).toEqual(data)
-      expect(fileData.name).toEqual(filename)
-    })
-
-    it('should store file without filename', async () => {
-      const data = 'hello world'
-
-      const hash = await bzz.uploadFile(BEE_URL, data, getPostageBatch())
-      const fileData = await bzz.downloadFile(BEE_URL, hash)
-
-      expect(Buffer.from(fileData.data).toString()).toEqual(data)
-    })
-
-    it('should store readable file', async () => {
-      const data = randomByteArray(5000, 0)
-      const filename = 'hello.txt'
-
-      const hash = await bzz.uploadFile(BEE_URL, Readable.from([data]), getPostageBatch(), filename, {
-        size: data.length,
-      })
-      const fileData = await bzz.downloadFile(BEE_URL, hash)
-
-      expect(fileData.data).toEqual(data)
-    })
-
-    it('should store file with a tag', async () => {
-      // Relates to how many chunks is uploaded which depends on manifest serialization.
-      // https://github.com/ethersphere/bee/pull/1501#discussion_r611385602
-      const EXPECTED_TAGS_COUNT = 6
-
-      const data = randomByteArray(5000, 1)
-      const filename = 'hello.txt'
-
-      const tag1 = await tag.createTag(BEE_URL)
-      await bzz.uploadFile(BEE_URL, data, getPostageBatch(), filename, { tag: tag1.uid })
-      const tag2 = await tag.retrieveTag(BEE_URL, tag1.uid)
-
-      expect(tag2.total).toEqual(EXPECTED_TAGS_COUNT)
-      expect(tag2.processed).toEqual(EXPECTED_TAGS_COUNT)
-    }, 5000)
-
-    it(
-      'should catch error',
-      async () => {
-        await expect(bzz.downloadFile(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-      },
-      BIG_FILE_TIMEOUT,
-    )
-
-    it(
-      'should upload bigger file',
-      async () => {
-        const data = new Uint8Array(32 * 1024 * 1024)
-        const response = await bzz.uploadFile(BEE_URL, data, getPostageBatch())
-
-        expect(typeof response).toEqual('string')
-      },
-      BIG_FILE_TIMEOUT,
-    )
-  })
-})

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

@@ -1,29 +0,0 @@
-import * as chunk from '../../../src/modules/chunk'
-import { beeUrl, invalidReference, ERR_TIMEOUT, getPostageBatch } from '../../utils'
-
-const BEE_URL = beeUrl()
-
-describe('modules/chunk', () => {
-  it('should store and retrieve data', async () => {
-    const payload = new Uint8Array([1, 2, 3])
-    // span is the payload length encoded as uint64 little endian
-    const span = new Uint8Array([payload.length, 0, 0, 0, 0, 0, 0, 0])
-    const data = new Uint8Array([...span, ...payload])
-    // the hash is hardcoded because we would need the bmt hasher otherwise
-    const reference = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338'
-
-    const response = await chunk.upload(BEE_URL, data, getPostageBatch())
-    expect(response).toEqual(reference)
-
-    const downloadedData = await chunk.download(BEE_URL, response)
-    expect(downloadedData).toEqual(data)
-  })
-
-  it(
-    'should catch error',
-    async () => {
-      await expect(chunk.download(BEE_URL, invalidReference)).rejects.toThrow('Not Found')
-    },
-    ERR_TIMEOUT,
-  )
-})

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

@@ -1,70 +0,0 @@
-import { beeDebugUrl, beePeerDebugUrl, commonMatchers } from '../../../utils'
-import * as balance from '../../../../src/modules/debug/balance'
-import * as connectivity from '../../../../src/modules/debug/connectivity'
-
-// helper function to get the peer overlay address
-async function getPeerOverlay() {
-  const nodeAddresses = await connectivity.getNodeAddresses(beePeerDebugUrl())
-
-  return nodeAddresses.overlay
-}
-
-commonMatchers()
-
-describe('balance', () => {
-  describe('balances', () => {
-    test('Get the balances with all known peers including prepaid services', async () => {
-      const peerOverlay = await getPeerOverlay()
-      const response = await balance.getAllBalances(beeDebugUrl())
-
-      expect(response.balances).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            peer: expect.any(String),
-            balance: expect.any(String),
-          }),
-        ]),
-      )
-
-      const peerBalances = response.balances.map(peerBalance => peerBalance.peer)
-
-      expect(peerBalances.includes(peerOverlay)).toBeTruthy()
-    })
-
-    test('Get the balances with all known peers including prepaid services', async () => {
-      const peerOverlay = await getPeerOverlay()
-      const peerBalance = await balance.getPeerBalance(beeDebugUrl(), peerOverlay)
-
-      expect(peerBalance.peer).toEqual(peerOverlay)
-      expect(peerBalance.balance).toBeNumberString()
-    })
-  })
-
-  describe('consumed', () => {
-    test('Get the past due consumption balances with all known peers', async () => {
-      const peerOverlay = await getPeerOverlay()
-      const response = await balance.getPastDueConsumptionBalances(beeDebugUrl())
-
-      expect(response.balances).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            peer: expect.any(String),
-            balance: expect.any(String),
-          }),
-        ]),
-      )
-
-      const peerBalances = response.balances.map(peerBalance => peerBalance.peer)
-
-      expect(peerBalances.includes(peerOverlay)).toBeTruthy()
-    })
-
-    test('Get the past due consumption balance with a specific peer', async () => {
-      const peerOverlay = await getPeerOverlay()
-      const peerBalance = await balance.getPastDueConsumptionPeerBalance(beeDebugUrl(), peerOverlay)
-
-      expect(peerBalance.peer).toEqual(peerOverlay)
-      expect(peerBalance.balance).toBeNumberString()
-    })
-  })
-})

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

@@ -1,64 +0,0 @@
-import {
-  depositTokens,
-  getChequebookAddress,
-  getChequebookBalance,
-  getLastCheques,
-  withdrawTokens,
-} from '../../../../src/modules/debug/chequebook'
-import { NumberString } from '../../../../src/types'
-import { isPrefixedHexString } from '../../../../src/utils/hex'
-import { beeDebugUrl, commonMatchers, sleep } from '../../../utils'
-
-if (process.env.BEE_TEST_CHEQUEBOOK) {
-  commonMatchers()
-
-  describe('swap enabled chequebook', () => {
-    test('address', async () => {
-      const response = await getChequebookAddress(beeDebugUrl())
-
-      expect(isPrefixedHexString(response.chequebookAddress)).toBeTruthy()
-    })
-
-    test('balance', async () => {
-      const response = await getChequebookBalance(beeDebugUrl())
-
-      expect(response.availableBalance).toBeNumberString()
-      expect(response.totalBalance).toBeNumberString()
-    })
-
-    const TRANSACTION_TIMEOUT = 20 * 1000
-
-    const withDrawDepositTest = (amount: number | NumberString) => async () => {
-      const withdrawResponse = await withdrawTokens(beeDebugUrl(), amount)
-      expect(withdrawResponse).toBeType('string')
-
-      // TODO avoid sleep in tests
-      // See https://github.com/ethersphere/bee/issues/1191
-      await sleep(TRANSACTION_TIMEOUT)
-
-      const depositResponse = await depositTokens(beeDebugUrl(), amount)
-
-      expect(depositResponse).toBeType('string')
-
-      // TODO avoid sleep in tests
-      // See https://github.com/ethersphere/bee/issues/1191
-      await sleep(TRANSACTION_TIMEOUT)
-    }
-
-    test('withdraw and deposit string', async () => await withDrawDepositTest('5'), 3 * TRANSACTION_TIMEOUT)
-    test('withdraw and deposit integer', async () => await withDrawDepositTest(5), 3 * TRANSACTION_TIMEOUT)
-
-    test('get last cheques for all peers', async () => {
-      const response = await getLastCheques(beeDebugUrl())
-
-      expect(Array.isArray(response.lastcheques)).toBeTruthy()
-    })
-  })
-} else {
-  test('swap disabled chequebook', () => {
-    // eslint-disable-next-line no-console
-    console.log(`
-      Chequebook tests are disabled because BEE_TEST_CHEQUEBOOK environment variable is not set.
-    `)
-  })
-}