@ethersphere/bee-js 1.2.1 → 3.0.0

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

@@ -1,365 +0,0 @@
-import {
-  assertAllIsDone,
-  cashoutLastChequeMock,
-  createPostageBatchMock,
-  depositTokensMock,
-  MOCK_SERVER_URL,
-  withdrawTokensMock,
-} from './nock'
-import { BatchId, BeeArgumentError, BeeDebug } from '../../src'
-import { testAddress } from '../utils'
-import { testAddressAssertions, testBatchIdAssertion } from './assertions'
-
-describe('BeeDebug class', () => {
-  function testUrl(url: unknown): void {
-    it(`should not accept invalid url '${url}'`, () => {
-      try {
-        new BeeDebug(url as string)
-        fail('BeeDebug constructor should have thrown error.')
-      } catch (e) {
-        if (e instanceof BeeArgumentError) {
-          expect(e.value).toEqual(url)
-
-          return
-        }
-
-        throw e
-      }
-    })
-  }
-
-  testUrl('')
-  testUrl(null)
-  testUrl(undefined)
-  testUrl(1)
-  testUrl('some-invalid-url')
-  testUrl('invalid:protocol')
-  // eslint-disable-next-line no-script-url
-  testUrl('javascript:console.log()')
-  testUrl('ws://localhost:1633')
-
-  describe('removePeer', () => {
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.removePeer(input as string)
-    })
-  })
-
-  describe('pingPeer', () => {
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.pingPeer(input as string)
-    })
-  })
-
-  describe('getPeerBalance', () => {
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.getPeerBalance(input as string)
-    })
-  })
-
-  describe('getPastDueConsumptionPeerBalance', () => {
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.getPastDueConsumptionPeerBalance(input as string)
-    })
-  })
-
-  describe('getLastChequesForPeer', () => {
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.getLastChequesForPeer(input as string)
-    })
-  })
-
-  describe('getLastCashoutAction', () => {
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.getLastCashoutAction(input as string)
-    })
-  })
-
-  describe('getSettlements', () => {
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.getSettlements(input as string)
-    })
-  })
-
-  describe('cashoutLastCheque', () => {
-    const TRANSACTION_HASH = '36b7efd913ca4cf880b8eeac5093fa27b0825906c600685b6abdd6566e6cfe8f'
-    const CASHOUT_RESPONSE = {
-      transactionHash: TRANSACTION_HASH,
-    }
-
-    it('should not pass headers if no gas price is specified', async () => {
-      cashoutLastChequeMock(testAddress).reply(201, CASHOUT_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.cashoutLastCheque(testAddress)).resolves.toEqual(TRANSACTION_HASH)
-      assertAllIsDone()
-    })
-
-    it('should pass headers if gas price is specified', async () => {
-      cashoutLastChequeMock(testAddress, '100000000000').reply(201, CASHOUT_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.cashoutLastCheque(testAddress, { gasPrice: '100000000000' })).resolves.toEqual(TRANSACTION_HASH)
-      assertAllIsDone()
-    })
-
-    it('should pass headers if gas limit is specified', async () => {
-      cashoutLastChequeMock(testAddress, undefined, '100000000000').reply(201, CASHOUT_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.cashoutLastCheque(testAddress, { gasLimit: '100000000000' })).resolves.toEqual(TRANSACTION_HASH)
-      assertAllIsDone()
-    })
-
-    testAddressAssertions(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.cashoutLastCheque(input as string)
-    })
-
-    it('should throw error if passed wrong gas price input', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.cashoutLastCheque(testAddress, { gasPrice: 'asd' })).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Input testing
-      await expect(bee.cashoutLastCheque(testAddress, { gasPrice: true })).rejects.toThrow(TypeError)
-      await expect(bee.cashoutLastCheque(testAddress, { gasPrice: '-1' })).rejects.toThrow(BeeArgumentError)
-    })
-
-    it('should throw error if passed wrong gas limit input', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.cashoutLastCheque(testAddress, { gasLimit: 'asd' })).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Input testing
-      await expect(bee.cashoutLastCheque(testAddress, { gasLimit: true })).rejects.toThrow(TypeError)
-      await expect(bee.cashoutLastCheque(testAddress, { gasLimit: '-1' })).rejects.toThrow(BeeArgumentError)
-    })
-  })
-
-  describe('withdrawTokens', () => {
-    const TRANSACTION_HASH = '36b7efd913ca4cf880b8eeac5093fa27b0825906c600685b6abdd6566e6cfe8f'
-    const CASHOUT_RESPONSE = {
-      transactionHash: TRANSACTION_HASH,
-    }
-
-    it('should not pass headers if no gas price is specified', async () => {
-      withdrawTokensMock('10').reply(201, CASHOUT_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.withdrawTokens('10')).resolves.toEqual(TRANSACTION_HASH)
-      assertAllIsDone()
-    })
-
-    it('should pass headers if gas price is specified', async () => {
-      withdrawTokensMock('10', '100000000000').reply(201, CASHOUT_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.withdrawTokens('10', '100000000000')).resolves.toEqual(TRANSACTION_HASH)
-      assertAllIsDone()
-    })
-
-    it('should throw error if passed wrong amount', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.withdrawTokens(true)).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Input testing
-      await expect(bee.withdrawTokens('asd')).rejects.toThrow(TypeError)
-      // @ts-ignore: Input testing
-      await expect(bee.withdrawTokens(null)).rejects.toThrow(TypeError)
-      // @ts-ignore: Input testing
-      await expect(bee.withdrawTokens()).rejects.toThrow(TypeError)
-
-      await expect(bee.withdrawTokens('-1')).rejects.toThrow(BeeArgumentError)
-    })
-
-    it('should throw error if passed wrong gas price input', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.withdrawTokens('1', true)).rejects.toThrow(TypeError)
-      // @ts-ignore: Input testing
-      await expect(bee.withdrawTokens('1', 'asd')).rejects.toThrow(TypeError)
-      await expect(bee.withdrawTokens('1', '-1')).rejects.toThrow(BeeArgumentError)
-    })
-  })
-
-  describe('depositTokens', () => {
-    const TRANSACTION_HASH = '36b7efd913ca4cf880b8eeac5093fa27b0825906c600685b6abdd6566e6cfe8f'
-    const CASHOUT_RESPONSE = {
-      transactionHash: TRANSACTION_HASH,
-    }
-
-    it('should not pass headers if no gas price is specified', async () => {
-      depositTokensMock('10').reply(201, CASHOUT_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.depositTokens('10')).resolves.toEqual(TRANSACTION_HASH)
-      assertAllIsDone()
-    })
-
-    it('should pass headers if gas price is specified', async () => {
-      depositTokensMock('10', '100000000000').reply(201, CASHOUT_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.depositTokens('10', '100000000000')).resolves.toEqual(TRANSACTION_HASH)
-      assertAllIsDone()
-    })
-
-    it('should throw error if passed wrong amount', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.depositTokens(true)).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Input testing
-      await expect(bee.depositTokens('asd')).rejects.toThrow(TypeError)
-      // @ts-ignore: Input testing
-      await expect(bee.depositTokens(null)).rejects.toThrow(TypeError)
-      // @ts-ignore: Input testing
-      await expect(bee.depositTokens()).rejects.toThrow(TypeError)
-
-      await expect(bee.depositTokens('-1')).rejects.toThrow(BeeArgumentError)
-    })
-
-    it('should throw error if passed wrong gas price input', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.depositTokens('1', true)).rejects.toThrow(TypeError)
-      // @ts-ignore: Input testing
-      await expect(bee.depositTokens('1', 'asd')).rejects.toThrow(TypeError)
-      await expect(bee.depositTokens('1', '-1')).rejects.toThrow(BeeArgumentError)
-    })
-  })
-
-  describe('retrieveExtendedTag', () => {
-    it('should throw exception for bad Tag', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag('')).rejects.toThrow(TypeError)
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag(true)).rejects.toThrow(TypeError)
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag([])).rejects.toThrow(TypeError)
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag({})).rejects.toThrow(TypeError)
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag(null)).rejects.toThrow(TypeError)
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag(undefined)).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag({ total: true })).rejects.toThrow(TypeError)
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag({ total: 'asdf' })).rejects.toThrow(TypeError)
-      // @ts-ignore: Type testing
-      await expect(bee.retrieveExtendedTag({ total: null })).rejects.toThrow(TypeError)
-
-      await expect(bee.retrieveExtendedTag(-1)).rejects.toThrow(BeeArgumentError)
-    })
-  })
-
-  describe('createPostageBatch', () => {
-    const BATCH_ID = '36b7efd913ca4cf880b8eeac5093fa27b0825906c600685b6abdd6566e6cfe8f'
-    const BATCH_RESPONSE = {
-      batchID: BATCH_ID,
-    }
-
-    it('should not pass headers if no gas price is specified', async () => {
-      createPostageBatchMock('10', '17').reply(201, BATCH_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.createPostageBatch('10', 17)).resolves.toEqual(BATCH_ID)
-      assertAllIsDone()
-    })
-
-    it('should pass headers if gas price is specified', async () => {
-      createPostageBatchMock('10', '17', '100').reply(201, BATCH_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.createPostageBatch('10', 17, { gasPrice: '100' })).resolves.toEqual(BATCH_ID)
-      assertAllIsDone()
-    })
-
-    it('should pass headers if immutable flag is specified', async () => {
-      createPostageBatchMock('10', '17', undefined, undefined, 'true').reply(201, BATCH_RESPONSE)
-
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-      await expect(bee.createPostageBatch('10', 17, { immutableFlag: true })).resolves.toEqual(BATCH_ID)
-      assertAllIsDone()
-    })
-
-    it('should throw error if passed wrong gas price input', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.createPostageBatch('10', 17, { gasPrice: 'asd' })).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Input testing
-      await expect(bee.createPostageBatch('10', 17, { gasPrice: true })).rejects.toThrow(TypeError)
-      await expect(bee.createPostageBatch('10', 17, { gasPrice: '-1' })).rejects.toThrow(BeeArgumentError)
-    })
-
-    it('should throw error if passed wrong immutable input', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      // @ts-ignore: Input testing
-      await expect(bee.createPostageBatch('10', 17, { immutableFlag: 'asd' })).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Input testing
-      await expect(bee.createPostageBatch('10', 17, { immutableFlag: -1 })).rejects.toThrow(TypeError)
-
-      // @ts-ignore: Input testing
-      await expect(bee.createPostageBatch('10', 17, { immutableFlag: 'true' })).rejects.toThrow(TypeError)
-    })
-
-    it('should throw error if too small depth', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      await expect(bee.createPostageBatch('10', -1)).rejects.toThrow(BeeArgumentError)
-      await expect(bee.createPostageBatch('10', 15)).rejects.toThrow(BeeArgumentError)
-    })
-
-    it('should throw error if too big depth', async () => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      await expect(bee.createPostageBatch('10', 256)).rejects.toThrow(BeeArgumentError)
-    })
-  })
-
-  describe('getPostageBatch', () => {
-    testBatchIdAssertion(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.getPostageBatch(input as BatchId)
-    })
-  })
-
-  describe('getPostageBatchBuckets', () => {
-    testBatchIdAssertion(async (input: unknown) => {
-      const bee = new BeeDebug(MOCK_SERVER_URL)
-
-      return bee.getPostageBatchBuckets(input as BatchId)
-    })
-  })
-})

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

@@ -1,16 +0,0 @@
-import { bmtHash } from '../../../src/chunk/bmt'
-import { makeSpan } from '../../../src/chunk/span'
-import { bytesToHex } from '../../../src/utils/hex'
-
-describe('bmt', () => {
-  it('should produce correct BMT hash', () => {
-    const payload = new Uint8Array([1, 2, 3])
-    const span = makeSpan(payload.length)
-    const data = new Uint8Array([...span, ...payload])
-    const hash = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338'
-
-    const result = bmtHash(data)
-
-    expect(bytesToHex(result)).toEqual(hash)
-  })
-})

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

@@ -1,29 +0,0 @@
-import { assertBytes } from '../../../src/utils/bytes'
-import { makeContentAddressedChunk, assertValidChunkData } from '../../../src/chunk/cac'
-import { serializeBytes } from '../../../src/chunk/serialize'
-import { makeSpan } from '../../../src/chunk/span'
-import { hexToBytes, bytesToHex } from '../../../src/utils/hex'
-
-describe('cac', () => {
-  const payload = new Uint8Array([1, 2, 3])
-  const contentHash = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338'
-
-  test('content address chunk creation', () => {
-    const cac = makeContentAddressedChunk(payload)
-    const address = cac.address()
-
-    expect(bytesToHex(address)).toEqual(contentHash)
-  })
-
-  test('content address chunk verification', () => {
-    const validAddress = hexToBytes(contentHash)
-    assertBytes(validAddress, 32)
-    const invalidAddress = hexToBytes('ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4335')
-    assertBytes(invalidAddress, 32)
-
-    const data = serializeBytes(makeSpan(payload.length), payload)
-
-    expect(() => assertValidChunkData(data, validAddress)).not.toThrow()
-    expect(() => assertValidChunkData(data, invalidAddress)).toThrow()
-  })
-})

package/test/unit/chunk/serialize.spec.ts

@@ -1,24 +0,0 @@
-import { serializeBytes } from '../../../src/chunk/serialize'
-
-describe('serializeBytes', () => {
-  it('serializes', () => {
-    const a1 = new Uint8Array([1])
-    const a2 = new Uint8Array([2])
-    const a3 = new Uint8Array([3])
-    const expectedResult = new Uint8Array([1, 2, 3])
-
-    const result = serializeBytes(a1, a2, a3)
-
-    expect(result).toEqual(expectedResult)
-  })
-
-  it('serializes chunk data with span', () => {
-    const span = new Uint8Array(8)
-    const payload = new Uint8Array(4096)
-    const expectedResult = new Uint8Array(span.length + payload.length)
-
-    const result = serializeBytes(span, payload)
-
-    expect(result).toEqual(expectedResult)
-  })
-})

package/test/unit/chunk/signer.spec.ts

@@ -1,140 +0,0 @@
-import { sign, makePrivateKeySigner, makeSigner, recoverAddress } from '../../../src/chunk/signer'
-import { makeBytes, assertBytes, wrapBytesWithHelpers } from '../../../src/utils/bytes'
-import { HexString, hexToBytes, bytesToHex } from '../../../src/utils/hex'
-import { shorten, testIdentity } from '../../utils'
-import type { Signature, Signer } from '../../../src/types'
-
-describe('signer', () => {
-  const dataToSignBytes = hexToBytes('2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae' as HexString)
-  const dataToSignWithHelpers = wrapBytesWithHelpers(dataToSignBytes)
-
-  const expectedSignatureHex =
-    '336d24afef78c5883b96ad9a62552a8db3d236105cb059ddd04dc49680869dc16234f6852c277087f025d4114c4fac6b40295ecffd1194a84cdb91bd571769491b' as HexString
-  const expectedSignatureBytes = hexToBytes(expectedSignatureHex)
-
-  test('default signer (same data as Bee Go client)', async () => {
-    const privateKey = hexToBytes(testIdentity.privateKey)
-    assertBytes(privateKey, 32)
-
-    const signer = makePrivateKeySigner(privateKey)
-    const signature = await signer.sign(dataToSignWithHelpers)
-
-    expect(signature).toEqual(expectedSignatureBytes)
-  })
-
-  test('recover address from signature', () => {
-    const recoveredAddress = recoverAddress(expectedSignatureBytes as Signature, dataToSignWithHelpers)
-
-    expect(bytesToHex(recoveredAddress)).toEqual(testIdentity.address)
-  })
-
-  describe('makeSigner', () => {
-    test('converts string', async () => {
-      const signer = makeSigner(testIdentity.privateKey)
-      const signature = await signer.sign(dataToSignWithHelpers)
-
-      expect(bytesToHex(signer.address)).toEqual(testIdentity.address)
-      expect(signature).toEqual(expectedSignatureBytes)
-    })
-
-    test('converts uintarray', async () => {
-      const signer = makeSigner(hexToBytes(testIdentity.privateKey))
-      const signature = await signer.sign(dataToSignWithHelpers)
-
-      expect(bytesToHex(signer.address)).toEqual(testIdentity.address)
-      expect(signature).toEqual(expectedSignatureBytes)
-    })
-
-    test('returns already signer object', () => {
-      const zeroAddress = makeBytes(20)
-      const signerLikeObject = {
-        address: zeroAddress,
-        sign: () => {
-          // noop
-        },
-      }
-
-      const signer = makeSigner(signerLikeObject)
-
-      expect(signer.address).toEqual(zeroAddress)
-    })
-
-    test('throws for invalid data', () => {
-      const data = [
-        null,
-        123,
-        { some: 'property' },
-        undefined,
-        Symbol.for('symbol'),
-        { address: makeBytes(20), sign: 'not a function' },
-        {
-          address: makeBytes(10),
-          sign: () => {
-            // noop
-          },
-        },
-      ]
-
-      for (const el of data) {
-        expect(() => {
-          makeSigner(el)
-        }).toThrow(TypeError)
-      }
-    })
-  })
-
-  describe('sign', () => {
-    it('should wrap the digest with helpers', async () => {
-      const signer = {
-        sign: digest => {
-          expect(digest).toHaveProperty('hex')
-          expect(digest).toHaveProperty('text')
-          expect(digest).toHaveProperty('json')
-
-          return expectedSignatureHex
-        },
-        address: makeBytes(20),
-      } as Signer
-
-      const result = await sign(signer, dataToSignBytes)
-      expect(result).toEqual(expectedSignatureBytes)
-    })
-
-    function testSignerConversion(input: HexString, output: Uint8Array): void {
-      it(`should convert sign result ${shorten(input)}`, async () => {
-        const signer = {
-          sign: () => {
-            return input
-          },
-          address: makeBytes(20),
-        } as Signer
-
-        const result = await sign(signer, dataToSignBytes)
-        expect(result).toEqual(output)
-      })
-    }
-
-    testSignerConversion(expectedSignatureHex, expectedSignatureBytes)
-    testSignerConversion(`0x${expectedSignatureHex}`, expectedSignatureBytes)
-
-    function testSignerThrowing(input: unknown): void {
-      it(`should throw for invalid result ${shorten(input)}`, async () => {
-        const signer = {
-          sign: () => {
-            return input
-          },
-          address: makeBytes(20),
-        } as Signer
-
-        await expect(sign(signer, dataToSignBytes)).rejects.toThrow(TypeError)
-      })
-    }
-
-    testSignerThrowing('0x1234')
-    testSignerThrowing('1234')
-    testSignerThrowing('asd')
-    testSignerThrowing(1)
-    testSignerThrowing([])
-    testSignerThrowing({})
-  })
-})

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

@@ -1,25 +0,0 @@
-import { Bytes, assertBytes } from '../../../src/utils/bytes'
-import { makeSingleOwnerChunk } from '../../../src/chunk/soc'
-import { makeContentAddressedChunk } from '../../../src/chunk/cac'
-import { testIdentity } from '../../utils'
-import { makePrivateKeySigner } from '../../../src/chunk/signer'
-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('single owner chunk creation', async () => {
-    const cac = makeContentAddressedChunk(payload)
-    const soc = await makeSingleOwnerChunk(cac, identifier, signer)
-    const socAddress = bytesToHex(soc.address())
-    const owner = soc.owner()
-
-    expect(socAddress).toEqual(socHash)
-    expect(owner).toEqual(signer.address)
-  })
-})

package/test/unit/chunk/span.spec.ts

@@ -1,38 +0,0 @@
-import { makeSpan } from '../../../src/chunk/span'
-import { BeeArgumentError } from '../../../src/utils/error'
-
-describe('span', () => {
-  it('should construct correct span', () => {
-    const expected: [number, Uint8Array][] = [
-      [2 ** 0, new Uint8Array([0x01, 0, 0, 0, 0, 0, 0, 0])],
-      [2 ** 4, new Uint8Array([0x10, 0, 0, 0, 0, 0, 0, 0])],
-      [2 ** 8, new Uint8Array([0, 0x01, 0, 0, 0, 0, 0, 0])],
-      [2 ** 16, new Uint8Array([0, 0, 0x01, 0, 0, 0, 0, 0])],
-      [2 ** 24, new Uint8Array([0, 0, 0, 0x01, 0, 0, 0, 0])],
-      [2 ** 32 - 1, new Uint8Array([0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0])],
-    ]
-
-    expected.forEach(elem => {
-      const result = makeSpan(elem[0])
-      expect(result).toEqual(elem[1])
-    })
-  })
-
-  it('should throw error with negative length', () => {
-    const length = -1
-    const t = () => makeSpan(length)
-    expect(t).toThrow(BeeArgumentError)
-  })
-
-  it('should throw error with zero length', () => {
-    const length = 0
-    const t = () => makeSpan(length)
-    expect(t).toThrow(BeeArgumentError)
-  })
-
-  it('should throw error when it is too big', () => {
-    const length = 2 ** 32
-    const t = () => makeSpan(length)
-    expect(t).toThrow(BeeArgumentError)
-  })
-})