@ethersphere/bee-js 2.0.0 → 3.1.0

package/test/integration/bee-debug-class.spec.ts

@@ -1,85 +0,0 @@
-import { BeeArgumentError, BeeDebug } from '../../src'
-import { beeDebugUrl, commonMatchers, POSTAGE_BATCH_TIMEOUT } from '../utils'
-
-commonMatchers()
-
-describe('Bee Debug class', () => {
-  const BEE_DEBUG_URL = beeDebugUrl()
-  const beeDebug = new BeeDebug(BEE_DEBUG_URL)
-
-  describe('PostageBatch', () => {
-    it(
-      'should create a new postage batch with zero amount',
-      async () => {
-        const batchId = await beeDebug.createPostageBatch('0', 17)
-        const allBatches = await beeDebug.getAllPostageBatch()
-
-        expect(allBatches.find(batch => batch.batchID === batchId)).toBeTruthy()
-      },
-      POSTAGE_BATCH_TIMEOUT,
-    )
-
-    it(
-      'should have both immutable true and false',
-      async () => {
-        await beeDebug.createPostageBatch('1', 17, { immutableFlag: true })
-        await beeDebug.createPostageBatch('1', 17, { immutableFlag: false })
-        const allBatches = await beeDebug.getAllPostageBatch()
-
-        expect(allBatches.find(batch => batch.immutableFlag === true)).toBeTruthy()
-        expect(allBatches.find(batch => batch.immutableFlag === false)).toBeTruthy()
-      },
-      POSTAGE_BATCH_TIMEOUT * 2,
-    )
-
-    it('should have all properties', async () => {
-      const allBatches = await beeDebug.getAllPostageBatch()
-
-      expect(allBatches.length).toBeGreaterThan(0)
-
-      expect(allBatches).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            batchID: expect.any(String),
-            utilization: expect.any(Number),
-            usable: expect.any(Boolean),
-            label: expect.any(String),
-            depth: expect.any(Number),
-            amount: expect.any(String),
-            bucketDepth: expect.any(Number),
-            blockNumber: expect.any(Number),
-            immutableFlag: expect.any(Boolean),
-            batchTTL: expect.any(Number),
-            exists: expect.any(Boolean),
-          }),
-        ]),
-      )
-    })
-
-    it('buckets should have all properties', async () => {
-      const allBatches = await beeDebug.getAllPostageBatch()
-
-      expect(allBatches.length).toBeGreaterThan(0)
-      const batchId = allBatches[0].batchID
-      const buckets = await beeDebug.getPostageBatchBuckets(batchId)
-
-      expect(buckets).toEqual(
-        expect.objectContaining({
-          depth: expect.any(Number),
-          bucketDepth: expect.any(Number),
-          bucketUpperBound: expect.any(Number),
-          buckets: expect.arrayContaining([
-            expect.objectContaining({
-              bucketID: expect.any(Number),
-              collisions: expect.any(Number),
-            }),
-          ]),
-        }),
-      )
-    })
-
-    it('should error with negative amount', async () => {
-      await expect(beeDebug.createPostageBatch('-1', 17)).rejects.toThrowError(BeeArgumentError)
-    })
-  })
-})

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

@@ -1,33 +0,0 @@
-import { bmtHash } from '../../../src/chunk/bmt'
-import { beeKy, 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(beeKy(), 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(beeKy(), 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 { beeKy, 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(beeKy(), 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(beeKy(), 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 { beeKy, 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(beeKy(), soc, getPostageBatch())
-
-    expect(response).toEqual(socAddress)
-  })
-
-  test('download single owner chunk', async () => {
-    const data = await chunkAPI.download(beeKy(), 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 { beeKy, 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 { Ky, PrivateKeyBytes, Signer, Topic } from '../../../src/types'
-import { BeeResponseError } from '../../../src'
-
-function makeChunk(index: number) {
-  return makeContentAddressedChunk(new Uint8Array([index]))
-}
-
-async function uploadChunk(ky: Ky, index: number): Promise<ChunkReference> {
-  const chunk = makeChunk(index)
-  const reference = await chunkAPI.upload(ky, 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(ky: Ky, signer: Signer, topic: Topic, index: Index, reference: ChunkReference) {
-  try {
-    await uploadFeedUpdate(ky, 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 BEE_KY = beeKy()
-  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(BEE_KY, owner, emptyTopic)
-
-      expect(index).toEqual('0000000000000000')
-    },
-    ERR_TIMEOUT,
-  )
-
-  test('feed update', async () => {
-    const uploadedChunk = await uploadChunk(BEE_KY, 0)
-    await tryUploadFeedUpdate(BEE_KY, signer, topic, 0, uploadedChunk)
-
-    const feedUpdate = await fetchFeedUpdate(BEE_KY, 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(BEE_KY, 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(BEE_KY, 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 { invalidReference, ERR_TIMEOUT, getPostageBatch, beeKy } from '../../utils'
-
-const BEE_KY = beeKy()
-
-describe('modules/bytes', () => {
-  it('should store and retrieve data', async () => {
-    const data = 'hello world'
-
-    const result = await bytes.upload(BEE_KY, data, getPostageBatch())
-    const downloadedData = await bytes.download(BEE_KY, result.reference)
-
-    expect(Buffer.from(downloadedData).toString()).toEqual(data)
-  })
-
-  it(
-    'should catch error',
-    async () => {
-      await expect(bytes.download(BEE_KY, invalidReference)).rejects.toThrow('Not Found')
-    },
-    ERR_TIMEOUT,
-  )
-})

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

@@ -1,265 +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 { beeKy, BIG_FILE_TIMEOUT, getPostageBatch, invalidReference, randomByteArray } from '../../utils'
-import { Readable } from 'stream'
-
-const BEE_KY = beeKy()
-
-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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch())
-      const file = await bzz.downloadFile(BEE_KY, result.reference, 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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch())
-      const file = await bzz.downloadFile(BEE_KY, result.reference, 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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch(), { pin: true })
-      const file = await bzz.downloadFile(BEE_KY, result.reference, 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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch(), { encrypt: true })
-      const file = await bzz.downloadFile(BEE_KY, result.reference, directoryStructure[0].path)
-
-      expect(file.name).toEqual(directoryStructure[0].path)
-      expect(file.data).toEqual(directoryStructure[0].data)
-      expect(result.reference.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_KY, directoryStructure, getPostageBatch())
-
-        expect(response).toEqual(
-          expect.objectContaining({
-            reference: expect.any(String),
-            tagUid: expect.any(Number),
-          }),
-        )
-      },
-      BIG_FILE_TIMEOUT,
-    )
-
-    it('should store and retrieve collection', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-        {
-          path: '1',
-          data: Uint8Array.from([1]),
-        },
-      ]
-
-      const result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch())
-
-      const file0 = await bzz.downloadFile(BEE_KY, result.reference, directoryStructure[0].path)
-      expect(file0.name).toEqual(directoryStructure[0].path)
-      expect(file0.data).toEqual(directoryStructure[0].data)
-
-      const file1 = await bzz.downloadFile(BEE_KY, result.reference, 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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch(), {
-        indexDocument: '0',
-      })
-
-      const indexFile = await bzz.downloadFile(BEE_KY, result.reference)
-      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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch(), {
-        errorDocument: '0',
-      })
-
-      const errorFile = await bzz.downloadFile(BEE_KY, result.reference, '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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch())
-
-      const file3 = await bzz.downloadFile(BEE_KY, result.reference, `${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 result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch(), {
-        indexDocument: `${fileName}`,
-      })
-
-      const file1 = await bzz.downloadFile(BEE_KY, result.reference)
-      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 result = await bzz.uploadFile(BEE_KY, data, getPostageBatch(), filename)
-      const fileData = await bzz.downloadFile(BEE_KY, result.reference)
-
-      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 result = await bzz.uploadFile(BEE_KY, data, getPostageBatch())
-      const fileData = await bzz.downloadFile(BEE_KY, result.reference)
-
-      expect(Buffer.from(fileData.data).toString()).toEqual(data)
-    })
-
-    it('should store readable file', async () => {
-      const data = randomByteArray(5000, 1)
-      const filename = 'hello.txt'
-
-      const result = await bzz.uploadFile(BEE_KY, Readable.from([data]), getPostageBatch(), filename, {
-        size: data.length,
-      })
-      const fileData = await bzz.downloadFile(BEE_KY, result.reference)
-
-      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, 2)
-      const filename = 'hello.txt'
-
-      const tag1 = await tag.createTag(BEE_KY)
-      await bzz.uploadFile(BEE_KY, data, getPostageBatch(), filename, { tag: tag1.uid })
-      const tag2 = await tag.retrieveTag(BEE_KY, 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_KY, 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_KY, data, getPostageBatch())
-
-        expect(response).toEqual(
-          expect.objectContaining({
-            reference: expect.any(String),
-            tagUid: expect.any(Number),
-          }),
-        )
-      },
-      BIG_FILE_TIMEOUT,
-    )
-  })
-})

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

@@ -1,29 +0,0 @@
-import * as chunk from '../../../src/modules/chunk'
-import { invalidReference, ERR_TIMEOUT, getPostageBatch, beeKy } from '../../utils'
-
-const BEE_KY = beeKy()
-
-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_KY, data, getPostageBatch())
-    expect(response).toEqual(reference)
-
-    const downloadedData = await chunk.download(BEE_KY, response)
-    expect(downloadedData).toEqual(data)
-  })
-
-  it(
-    'should catch error',
-    async () => {
-      await expect(chunk.download(BEE_KY, invalidReference)).rejects.toThrow('Not Found')
-    },
-    ERR_TIMEOUT,
-  )
-})

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

@@ -1,70 +0,0 @@
-import { beeDebugKy, beePeerDebugKy, 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(beePeerDebugKy())
-
-  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(beeDebugKy())
-
-      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(beeDebugKy(), 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(beeDebugKy())
-
-      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(beeDebugKy(), peerOverlay)
-
-      expect(peerBalance.peer).toEqual(peerOverlay)
-      expect(peerBalance.balance).toBeNumberString()
-    })
-  })
-})