@ethersphere/bee-js 2.0.0 → 3.1.0

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 { beeDebugKy, commonMatchers, sleep } from '../../../utils'
-
-if (process.env.BEE_TEST_CHEQUEBOOK) {
-  commonMatchers()
-
-  describe('swap enabled chequebook', () => {
-    test('address', async () => {
-      const response = await getChequebookAddress(beeDebugKy())
-
-      expect(isPrefixedHexString(response.chequebookAddress)).toBeTruthy()
-    })
-
-    test('balance', async () => {
-      const response = await getChequebookBalance(beeDebugKy())
-
-      expect(response.availableBalance).toBeNumberString()
-      expect(response.totalBalance).toBeNumberString()
-    })
-
-    const TRANSACTION_TIMEOUT = 20 * 1000
-
-    const withDrawDepositTest = (amount: number | NumberString) => async () => {
-      const withdrawResponse = await withdrawTokens(beeDebugKy(), 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(beeDebugKy(), 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(beeDebugKy())
-
-      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.
-    `)
-  })
-}

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

@@ -1,69 +0,0 @@
-import {
-  getPeers,
-  getBlocklist,
-  getTopology,
-  getNodeAddresses,
-  pingPeer,
-} from '../../../../src/modules/debug/connectivity'
-import { beeDebugKy } from '../../../utils'
-
-describe('modules/debug/connectivity', () => {
-  test('getPeers', async () => {
-    const peers = await getPeers(beeDebugKy())
-
-    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(beeDebugKy())
-
-    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(beeDebugKy())
-
-    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(beeDebugKy())
-
-    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(beeDebugKy())
-    const res = await pingPeer(beeDebugKy(), 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 { beeDebugKy, commonMatchers } from '../../../utils'
-
-commonMatchers()
-
-describe('settlements', () => {
-  test('all settlements', async () => {
-    const response = await settlements.getAllSettlements(beeDebugKy())
-
-    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(beeDebugKy(), 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 { beeDebugKy, commonMatchers } from '../../../utils'
-import * as states from '../../../../src/modules/debug/states'
-
-const BEE_DEBUG_URL = beeDebugKy()
-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 { beeDebugKy } 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 = beeDebugKy()
-
-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 { beeDebugKy, beeKy } from '../../../utils'
-
-const BEE_URL = beeKy()
-const BEE_DEBUG_KY = beeDebugKy()
-
-describe('modules/tag', () => {
-  it('should retrieve extended tag', async () => {
-    const tag1 = await beeTag.createTag(BEE_URL)
-    const tag2 = await beeDebugTag.retrieveExtendedTag(BEE_DEBUG_KY, 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/debug/transactions.spec.ts

@@ -1,10 +0,0 @@
-import * as transactions from '../../../../src/modules/debug/transactions'
-import { beeDebugKy, commonMatchers } from '../../../utils'
-
-commonMatchers()
-
-describe('transactions', () => {
-  it('should get at least empty array for listing', async () => {
-    await expect(transactions.getAllTransactions(beeDebugKy())).resolves.toBeType('array')
-  })
-})

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 {
-  beeKy,
-  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 BEE_KY = beeKy()
-  const owner = makeHexString(testIdentity.address, 40)
-  const topic = '0000000000000000000000000000000000000000000000000000000000000000' as Topic
-
-  test('feed manifest creation', async () => {
-    const reference = '92442c3e08a308aeba8e2d231733ec57011a203354cad24129e7e0c37bac0cbe'
-    const response = await createFeedManifest(BEE_KY, owner, topic, getPostageBatch())
-
-    expect(response).toEqual(reference)
-  })
-
-  test(
-    'empty feed update',
-    async () => {
-      const emptyTopic = '1000000000000000000000000000000000000000000000000000000000000000' as Topic
-      const feedUpdate = fetchFeedUpdate(BEE_KY, 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(BEE_KY, owner, identifier, signature, socData, getPostageBatch())
-    expect(socResponse).toBeType('string')
-
-    const feedUpdate = await fetchFeedUpdate(BEE_KY, 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 {
-  invalidReference,
-  randomByteArray,
-  testChunkData,
-  testChunkHash,
-  ERR_TIMEOUT,
-  getPostageBatch,
-  commonMatchers,
-  beeKy,
-} from '../../utils'
-import { Collection } from '../../../src/types'
-
-const BEE_KY = beeKy()
-commonMatchers()
-
-describe('modules/pin', () => {
-  describe('should work with files', () => {
-    const randomData = randomByteArray(5000)
-
-    it('should pin an existing file', async () => {
-      const result = await bzz.uploadFile(BEE_KY, randomData, getPostageBatch())
-      await pinning.pin(BEE_KY, result.reference)
-    })
-
-    it('should unpin an existing file', async () => {
-      const result = await bzz.uploadFile(BEE_KY, randomData, getPostageBatch())
-      await pinning.unpin(BEE_KY, result.reference)
-    })
-
-    it(
-      'should not pin a non-existing file',
-      async () => {
-        await expect(pinning.pin(BEE_KY, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing file', async () => {
-      await expect(pinning.unpin(BEE_KY, 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 result = await bzz.uploadCollection(BEE_KY, testCollection, getPostageBatch())
-      await pinning.pin(BEE_KY, result.reference) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it('should unpin an existing collections', async () => {
-      const result = await bzz.uploadCollection(BEE_KY, testCollection, getPostageBatch())
-      await pinning.unpin(BEE_KY, result.reference) // 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_KY, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing collections', async () => {
-      await expect(pinning.unpin(BEE_KY, invalidReference)).rejects.toThrow('Not Found')
-    })
-  })
-
-  describe('should work with data', () => {
-    const randomData = randomByteArray(5000)
-
-    it('should pin existing data', async () => {
-      const result = await bytes.upload(BEE_KY, randomData, getPostageBatch())
-      await pinning.pin(BEE_KY, result.reference) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-
-    it('should unpin existing data', async () => {
-      const result = await bytes.upload(BEE_KY, randomData, getPostageBatch())
-      await pinning.pin(BEE_KY, result.reference) // 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_KY, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing data', async () => {
-      await expect(pinning.unpin(BEE_KY, invalidReference)).rejects.toThrow('Not Found')
-    })
-  })
-
-  describe('should work with chunks', () => {
-    it('should pin existing chunk', async () => {
-      const chunkReference = await chunk.upload(BEE_KY, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.pin(BEE_KY, 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_KY, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.unpin(BEE_KY, 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_KY, invalidReference)).rejects.toThrow('Not Found')
-      },
-      ERR_TIMEOUT,
-    )
-
-    it('should not unpin a non-existing chunk', async () => {
-      await expect(pinning.unpin(BEE_KY, invalidReference)).rejects.toThrow('Not Found')
-    })
-
-    it('should return pinning status of existing chunk', async () => {
-      const chunkReference = await chunk.upload(BEE_KY, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.pin(BEE_KY, testChunkHash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-      const pinningStatus = await pinning.getPin(BEE_KY, testChunkHash)
-      expect(pinningStatus.reference).toEqual(testChunkHash)
-    })
-
-    it('should not return pinning status of non-existing chunk', async () => {
-      await expect(pinning.getPin(BEE_KY, invalidReference)).rejects.toThrow('Not Found')
-    })
-
-    it('should return list of pinned chunks', async () => {
-      const chunkReference = await chunk.upload(BEE_KY, testChunkData, getPostageBatch())
-      expect(chunkReference).toEqual(testChunkHash)
-
-      await pinning.pin(BEE_KY, testChunkHash) // Nothing is asserted as nothing is returned, will throw error if something is wrong
-    })
-  })
-})

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

@@ -1,97 +0,0 @@
-import * as pss from '../../../src/modules/pss'
-import * as connectivity from '../../../src/modules/debug/connectivity'
-import { beeDebugKy, beeKy, beePeerDebugUrl, beePeerKy, beeUrl, getPostageBatch, PSS_TIMEOUT } from '../../utils'
-import { makeMaxTarget } from '../../../src/utils/pss'
-
-const BEE_KY = beeKy()
-const BEE_URL = beeUrl()
-const BEE_PEER_KY = beePeerKy()
-const BEE_DEBUG_KY = beeDebugKy()
-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 peers = await connectivity.getPeers(BEE_DEBUG_KY)
-      expect(peers.length).toBeGreaterThan(0)
-
-      const target = peers[0].address
-      await pss.send(BEE_KY, topic, makeMaxTarget(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 addresses = await connectivity.getNodeAddresses(BEE_DEBUG_KY)
-          const target = addresses.overlay
-          await pss.send(BEE_PEER_KY, topic, makeMaxTarget(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 addresses = await connectivity.getNodeAddresses(BEE_DEBUG_KY)
-          const target = addresses.overlay
-          const recipient = addresses.pssPublicKey
-          await pss.send(
-            BEE_PEER_KY,
-            topic,
-            makeMaxTarget(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 { beeKy } from '../../utils'
-
-const BEE_KY = beeKy()
-
-describe('checkConnection', () => {
-  test('should connect to a running node', async () => {
-    await status.checkConnection(BEE_KY)
-  })
-})

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 { beeKy, getPostageBatch } from '../../utils'
-
-const BEE_KY = beeKy()
-
-describe('modules/stewardship', () => {
-  describe('collections', () => {
-    it('should reupload directory', async () => {
-      const directoryStructure: Collection<Uint8Array> = [
-        {
-          path: '0',
-          data: Uint8Array.from([0]),
-        },
-      ]
-
-      const result = await bzz.uploadCollection(BEE_KY, directoryStructure, getPostageBatch(), { pin: true })
-      await stewardship.reupload(BEE_KY, result.reference) // 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 result = await bzz.uploadFile(BEE_KY, data, getPostageBatch(), filename, { pin: true })
-      await stewardship.reupload(BEE_KY, result.reference) // Does not return anything, but will throw error if something is wrong
-    })
-  })
-})