@ethersphere/bee-js 1.2.1 → 3.0.0

package/test/unit/feed/json.spec.ts

@@ -1,73 +0,0 @@
-import { Arg, Substitute } from '@fluffy-spoon/substitute'
-import { AnyJson, Bee, FeedWriter, Reference } from '../../../src'
-import { testAddress, testBatchId, testChunkHash } from '../../utils'
-import { getJsonData, setJsonData } from '../../../src/feed/json'
-import { FetchFeedUpdateResponse } from '../../../src/modules/feed'
-import { wrapBytesWithHelpers } from '../../../src/utils/bytes'
-
-interface CircularReference {
-  otherData: 123
-  myself?: CircularReference
-}
-
-describe('JsonFeed', () => {
-  const DATA_REFERENCE = testChunkHash as Reference
-  const FEED_REFERENCE_HASH = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a1111' as Reference
-  const FEED_REFERENCE = {
-    reference: FEED_REFERENCE_HASH,
-  } as FetchFeedUpdateResponse
-
-  function testSet(data: unknown, expectedBytes: Uint8Array): void {
-    it(`should set feed for data: ${data}`, async () => {
-      const bee = Substitute.for<Bee>()
-      bee.uploadData(Arg.all()).resolves(DATA_REFERENCE)
-
-      const writer = Substitute.for<FeedWriter>()
-      writer.upload(Arg.all()).resolves(FEED_REFERENCE_HASH)
-
-      await expect(setJsonData(bee, writer, testAddress, data as AnyJson)).resolves.toEqual(FEED_REFERENCE_HASH)
-      bee.received(1).uploadData(testAddress, expectedBytes)
-      writer.received(1).upload(testAddress, DATA_REFERENCE)
-    })
-
-    it(`should get feed for data: ${data}`, async () => {
-      const bee = Substitute.for<Bee>()
-      bee.downloadData(Arg.all()).resolves(wrapBytesWithHelpers(expectedBytes))
-
-      const writer = Substitute.for<FeedWriter>()
-      writer.download().resolves(FEED_REFERENCE)
-
-      await expect(getJsonData(bee, writer)).resolves.toEqual(data)
-      bee.received(1).downloadData(FEED_REFERENCE_HASH)
-      writer.received(1).download()
-    })
-  }
-
-  testSet('', Uint8Array.from([34, 34]))
-  testSet('hello world', Uint8Array.from([34, 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 34]))
-  testSet(null, Uint8Array.from([110, 117, 108, 108]))
-  testSet(true, Uint8Array.from([116, 114, 117, 101]))
-  testSet(10, Uint8Array.from([49, 48]))
-  testSet([], Uint8Array.from([91, 93]))
-  testSet(
-    [1, 'hello', null],
-    Uint8Array.from([91, 49, 44, 34, 104, 101, 108, 108, 111, 34, 44, 110, 117, 108, 108, 93]),
-  )
-  // prettier-ignore
-  testSet(
-    { hello: 'world', from: null },
-    Uint8Array.from([123, 34, 104, 101, 108, 108, 111, 34, 58, 34, 119, 111, 114, 108, 100, 34, 44, 34, 102, 114, 111, 109, 34, 58, 110, 117, 108, 108, 125]),
-  )
-
-  it(`should fail for non-serializable data`, async () => {
-    const bee = Substitute.for<Bee>()
-    const writer = Substitute.for<FeedWriter>()
-    await expect(setJsonData(bee, writer, testAddress, BigInt(123) as unknown as AnyJson)).rejects.toThrow(TypeError)
-
-    const circularReference: CircularReference = { otherData: 123 }
-    circularReference.myself = circularReference
-
-    // @ts-ignore: Circular references are detected with TS, so we have to ts-ignore to test it.
-    await expect(setJsonData(bee, writer, testBatchId, circularReference)).rejects.toThrow(TypeError)
-  })
-})

package/test/unit/nock.ts

@@ -1,134 +0,0 @@
-import nock, { RequestHeaderMatcher } from 'nock'
-import { DEFAULT_FEED_TYPE, FeedType } from '../../src/feed/type'
-import { Reference } from '../../src/types'
-import { HexEthAddress } from '../../src/utils/eth'
-
-export const MOCK_SERVER_URL = 'http://localhost:12345/'
-
-// Endpoints
-const FEED_ENDPOINT = '/feeds'
-const BZZ_ENDPOINT = '/bzz'
-const BYTES_ENDPOINT = '/bytes'
-const POSTAGE_ENDPOINT = '/stamps'
-const CHEQUEBOOK_ENDPOINT = '/chequebook'
-
-export function assertAllIsDone(): void {
-  if (!nock.isDone()) {
-    throw new Error('Some expected request was not performed!')
-  }
-}
-
-export function fetchFeedUpdateMock(
-  address: HexEthAddress | string,
-  hashedTopic: string,
-  type: FeedType = DEFAULT_FEED_TYPE,
-): nock.Interceptor {
-  return nock(MOCK_SERVER_URL).get(`${FEED_ENDPOINT}/${address}/${hashedTopic}?type=${type}`)
-}
-
-export function downloadDataMock(reference: Reference | string): nock.Interceptor {
-  return nock(MOCK_SERVER_URL).get(`${BYTES_ENDPOINT}/${reference}`)
-}
-
-interface UploadOptions {
-  name?: string
-  tag?: number
-  pin?: boolean
-  encrypt?: boolean
-  collection?: boolean
-  indexDocument?: string
-  errorDocument?: string
-}
-
-function camelCaseToDashCase(str: string) {
-  return str.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`)
-}
-
-export function uploadFileMock(batchId: string, name?: string, options?: UploadOptions): nock.Interceptor {
-  // Prefixes the options with `swarm-` so the object can be used for required headers
-  const headers = Object.entries(options || {}).reduce<Record<string, string>>((prev, curr) => {
-    prev[`swarm-${camelCaseToDashCase(curr[0])}`] = curr[1]
-
-    return prev
-  }, {})
-
-  return nock(MOCK_SERVER_URL, { reqheaders: { 'swarm-postage-batch-id': batchId, ...headers } })
-    .post(`${BZZ_ENDPOINT}`)
-    .query({ name })
-}
-
-export function createPostageBatchMock(
-  amount: string,
-  depth: string,
-  gasPrice?: string,
-  label?: string,
-  immutableFlag?: string,
-): nock.Interceptor {
-  let nockScope: nock.Scope
-
-  const reqheaders: Record<string, RequestHeaderMatcher> = {}
-
-  if (immutableFlag) {
-    reqheaders.immutable = immutableFlag
-  }
-
-  if (gasPrice) {
-    reqheaders['gas-price'] = gasPrice
-  }
-
-  if (immutableFlag || gasPrice) {
-    nockScope = nock(MOCK_SERVER_URL, {
-      reqheaders,
-    })
-  } else {
-    nockScope = nock(MOCK_SERVER_URL)
-  }
-
-  const nockMock = nockScope.post(`${POSTAGE_ENDPOINT}/${amount}/${depth}`)
-
-  if (label) {
-    return nockMock.query({ label })
-  } else {
-    return nockMock
-  }
-}
-
-export function cashoutLastChequeMock(peer: string, gasPrice?: string, gasLimit?: string): nock.Interceptor {
-  const headers: Record<string, string> = {}
-
-  if (gasPrice) {
-    headers['gas-price'] = gasPrice
-  }
-
-  if (gasLimit) {
-    headers['gas-limit'] = gasLimit
-  }
-
-  return nock(MOCK_SERVER_URL, {
-    reqheaders: headers,
-  }).post(`${CHEQUEBOOK_ENDPOINT}/cashout/${peer}`)
-}
-
-export function depositTokensMock(amount: string, gasPrice?: string): nock.Interceptor {
-  const headers: Record<string, string> = {}
-
-  if (gasPrice) {
-    headers['gas-price'] = gasPrice
-  }
-
-  return nock(MOCK_SERVER_URL, {
-    reqheaders: headers,
-  }).post(`${CHEQUEBOOK_ENDPOINT}/deposit?amount=${amount}`)
-}
-
-export function withdrawTokensMock(amount: string, gasPrice?: string): nock.Interceptor {
-  const headers: Record<string, string> = {}
-
-  if (gasPrice) {
-    headers['gas-price'] = gasPrice
-  }
-
-  return nock(MOCK_SERVER_URL, {
-    reqheaders: headers,
-  }).post(`${CHEQUEBOOK_ENDPOINT}/withdraw?amount=${amount}`)
-}

package/test/unit/utils/bytes.spec.ts

@@ -1,32 +0,0 @@
-import { wrapBytesWithHelpers } from '../../../src/utils/bytes'
-
-describe('bytes', () => {
-  describe('wrapBytesWithHelpers', () => {
-    it('should still be Uint8Array', () => {
-      const dataA = wrapBytesWithHelpers(new Uint8Array([104, 101, 108, 108, 111, 32]))
-      const dataB = wrapBytesWithHelpers(new Uint8Array([119, 111, 114, 108, 100]))
-
-      expect(dataA.text()).toEqual('hello ')
-      expect(dataB.text()).toEqual('world')
-      expect(new TextDecoder().decode(new Uint8Array([...dataA, ...dataB]))).toEqual('hello world')
-    })
-
-    it('should convert to string', () => {
-      const data = new Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])
-
-      expect(wrapBytesWithHelpers(data).text()).toEqual('hello world')
-      expect(wrapBytesWithHelpers(new Uint8Array([])).text()).toEqual('')
-      expect(() => wrapBytesWithHelpers(null as unknown as Uint8Array).text()).toThrowError()
-    })
-
-    it('should convert to json', () => {
-      const data = new Uint8Array([123, 34, 104, 101, 108, 108, 111, 34, 58, 34, 119, 111, 114, 108, 100, 34, 125])
-      expect(wrapBytesWithHelpers(data).json()).toEqual({ hello: 'world' })
-    })
-
-    it('should convert to hex', () => {
-      const data = new Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100])
-      expect(wrapBytesWithHelpers(data).hex()).toEqual('68656c6c6f20776f726c64')
-    })
-  })
-})

package/test/unit/utils/collection.spec.ts

@@ -1,22 +0,0 @@
-import { Utils } from '../../../src'
-
-function createFakeFile(): Partial<File> {
-  return {
-    size: 32,
-  }
-}
-
-describe('collection', () => {
-  test('should calculate folder size', async () => {
-    const size = await Utils.Collections.getFolderSize('./test/data')
-
-    expect(size).toBeGreaterThan(1)
-  })
-
-  test('should calculate collection size', async () => {
-    const files: File[] = [createFakeFile() as File]
-    const size = Utils.Collections.getCollectionSize(files)
-
-    expect(size).toBe(32)
-  })
-})

package/test/unit/utils/eth.spec.ts

@@ -1,224 +0,0 @@
-/* eslint @typescript-eslint/no-empty-function: 0 */
-import {
-  makeEthereumWalletSigner,
-  ethToSwarmAddress,
-  fromLittleEndian,
-  isHexEthAddress,
-  JsonRPC,
-  toLittleEndian,
-} from '../../../src/utils/eth'
-import { HexString, hexToBytes } from '../../../src/utils/hex'
-import { wrapBytesWithHelpers } from '../../../src/utils/bytes'
-
-describe('eth', () => {
-  describe('isEthAddress', () => {
-    const testValues = [
-      { value: () => {}, result: false },
-      { value: new Function(), result: false },
-      { value: 'function', result: false },
-      { value: {}, result: false },
-      { value: '0xc6d9d2cd449a754c494264e1809c50e34d64562b', result: true },
-      { value: '0xc6d9d2cd449a754c494264e1809c50e34d64562b'.toUpperCase(), result: true },
-      { value: 'c6d9d2cd449a754c494264e1809c50e34d64562b', result: true },
-      { value: 'c6d9d2cd449a754c494264e1809c50e34d64562b'.toUpperCase(), result: true },
-      { value: 'E247A45c287191d435A8a5D72A7C8dc030451E9F', result: true },
-      { value: '0xE247A45c287191d435A8a5D72A7C8dc030451E9F', result: true },
-      { value: '0xE247a45c287191d435A8a5D72A7C8dc030451E9F', result: false },
-      { value: '0xe247a45c287191d435a8a5d72a7c8dc030451e9f', result: true },
-      { value: '0xE247A45C287191D435A8A5D72A7C8DC030451E9F', result: true },
-      { value: '0XE247A45C287191D435A8A5D72A7C8DC030451E9F', result: true },
-      { value: '1234567890123456789012345678901234567890', result: true },
-      { value: 1234567890123456789012345678901234567890, result: false },
-    ]
-
-    testValues.forEach(({ value, result }) => {
-      test(`should test if value ${value} is address: ${result}`, () => {
-        expect(isHexEthAddress(value as unknown as string)).toBe(result)
-      })
-    })
-  })
-
-  describe('toLittleEndian', () => {
-    const testValues = [
-      { value: '1', result: '01' },
-      { value: 1, result: '01' },
-      { value: '123', result: '2301' },
-      { value: '0123', result: '2301' },
-      { value: '0123', result: '230100', pad: 6 },
-      { value: '0x0123', result: '230100', pad: 6 },
-      { value: 124, result: '7c' },
-      { value: 28721856816, result: '30c1f4af06' },
-    ]
-
-    testValues.forEach(({ value, result, pad }) => {
-      test(`should conver value ${value}${pad ? ` with pad ${pad}` : ''} to ${result}`, () => {
-        expect(toLittleEndian(value, pad)).toBe(result)
-      })
-    })
-
-    const wrongTestValues = [124.1, -1, () => {}, new Function(), Number.MAX_SAFE_INTEGER + 1]
-
-    wrongTestValues.forEach(value =>
-      test(`should throw for non string or positive int values: ${value}`, () => {
-        expect(() => toLittleEndian(value as unknown as string)).toThrow()
-      }),
-    )
-  })
-
-  describe('fromLittleEndian', () => {
-    const testValues = ['0123', '0x0123', 124, 28721856816]
-
-    testValues.forEach(value => {
-      test(`should conver value ${value} back and forth`, () => {
-        // We are converting first time to make for the comparison value to be padded and of the same type
-        const littleEndian1 = toLittleEndian(value)
-        const bigEndian = fromLittleEndian(littleEndian1)
-        const littleEndian2 = fromLittleEndian(bigEndian)
-
-        expect(littleEndian1).toBe(littleEndian2)
-      })
-    })
-
-    testValues.forEach(value => {
-      test(`should conver value ${value} back and forth with padding`, () => {
-        // We are converting first time to make for the comparison value to be padded and of the same type
-        const littleEndian1 = toLittleEndian(value, 10)
-        const bigEndian = fromLittleEndian(littleEndian1, 10)
-        const littleEndian2 = fromLittleEndian(bigEndian, 10)
-
-        expect(littleEndian1).toBe(littleEndian2)
-      })
-    })
-  })
-
-  describe('ethToSwarmAddress', () => {
-    const testValues = [
-      {
-        value: '1815cac638d1525b47f848daf02b7953e4edd15c',
-        result: 'b003840cac8f71dc3e6025dbccae613fd107dcb2fb187808b54cab92cfdd8299',
-      },
-      {
-        value: '0x1815cac638d1525b47f848daf02b7953e4edd15c',
-        result: 'b003840cac8f71dc3e6025dbccae613fd107dcb2fb187808b54cab92cfdd8299',
-      },
-      {
-        value: '0737e7c2e82fac12ca9e2bae01bea910593300e6',
-        result: 'ba898f4dd93c5b29dc2d9daff3ef3d183fa6b5bfac9c23d975c0ee1fb06fcad9',
-      },
-      {
-        value: 'd26bc1715e933bd5f8fad16310042f13abc16159',
-        result: '8e186467e0ed20b73667b5353210c0e650401cde0461c25c6b3e4a1f636b8cb8',
-      },
-    ]
-
-    testValues.forEach(({ value, result }) => {
-      test(`should create from ${value} to ${result}`, () => {
-        expect(ethToSwarmAddress(value)).toBe(result)
-      })
-    })
-
-    const wrongTestValues = [
-      {
-        address: '1815cac638d1525b47f848daf02b7953e4edd15cf',
-        netId: 1,
-      },
-      {
-        address: '1815cac638d1525b47f848daf02b7953e4edd15c',
-        netId: 0,
-      },
-      {
-        address: '1815cac638d1525b47f848daf02b7953e4edd15c',
-        netId: Number.MAX_SAFE_INTEGER + 1,
-      },
-      {
-        address: '1815cac638d1525b47f848daf02b7953e4edd15c',
-        netId: () => {},
-      },
-      {
-        address: () => {},
-        netId: 1,
-      },
-    ]
-
-    wrongTestValues.forEach((address, netId) =>
-      test(`should throw for incorrect values address ${address} netId ${netId}`, () => {
-        expect(() => ethToSwarmAddress(address as unknown as string, netId as unknown as number)).toThrow()
-      }),
-    )
-  })
-
-  describe('makeEthereumWalletSigner', () => {
-    const dataToSignBytes = hexToBytes('2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae' as HexString)
-    const dataToSignWithHelpers = wrapBytesWithHelpers(dataToSignBytes)
-    const expectedSignatureHex =
-      '0x336d24afef78c5883b96ad9a62552a8db3d236105cb059ddd04dc49680869dc16234f6852c277087f025d4114c4fac6b40295ecffd1194a84cdb91bd571769491b' as HexString
-
-    it('should detect valid interface', async () => {
-      await expect(makeEthereumWalletSigner({})).rejects.toThrow()
-      await expect(makeEthereumWalletSigner('' as unknown as JsonRPC)).rejects.toThrow(TypeError)
-      await expect(makeEthereumWalletSigner(1 as unknown as JsonRPC)).rejects.toThrow(TypeError)
-      await expect(makeEthereumWalletSigner(null as unknown as JsonRPC)).rejects.toThrow(TypeError)
-      await expect(makeEthereumWalletSigner(undefined as unknown as JsonRPC)).rejects.toThrow(TypeError)
-    })
-
-    it('should request address if not specified', async () => {
-      const providerMock = jest.fn()
-      providerMock.mockReturnValue(['0xf1B07aC6E91A423d9c3c834cc9d938E89E19334a'])
-
-      const signer = await makeEthereumWalletSigner({ request: providerMock } as JsonRPC)
-
-      expect(signer.address).toEqual(hexToBytes('f1B07aC6E91A423d9c3c834cc9d938E89E19334a'))
-      expect(providerMock.mock.calls.length).toEqual(1)
-      expect(providerMock.mock.calls[0][0]).toEqual({ method: 'eth_requestAccounts' })
-    })
-
-    it('should request signature when sign() is called', async () => {
-      const providerMock = jest.fn()
-      providerMock.mockReturnValue(expectedSignatureHex)
-
-      const signer = await makeEthereumWalletSigner(
-        { request: providerMock } as JsonRPC,
-        '0xf1B07aC6E91A423d9c3c834cc9d938E89E19334a',
-      )
-      await expect(signer.sign(dataToSignWithHelpers)).resolves.toEqual(expectedSignatureHex)
-      expect(providerMock.mock.calls.length).toEqual(1)
-      expect(providerMock.mock.calls[0][0]).toEqual({
-        jsonrpc: '2.0',
-        method: 'personal_sign',
-        params: [
-          '0x2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae',
-          '0xf1B07aC6E91A423d9c3c834cc9d938E89E19334a',
-        ],
-      })
-    })
-
-    it('should normalize hex prefix for address', async () => {
-      const providerMock = jest.fn()
-      providerMock.mockReturnValue(expectedSignatureHex)
-
-      const signer = await makeEthereumWalletSigner(
-        { request: providerMock } as JsonRPC,
-        'f1B07aC6E91A423d9c3c834cc9d938E89E19334a',
-      )
-      await expect(signer.sign(dataToSignWithHelpers)).resolves.toEqual(expectedSignatureHex)
-      expect(providerMock.mock.calls.length).toEqual(1)
-      expect(providerMock.mock.calls[0][0]).toEqual({
-        jsonrpc: '2.0',
-        method: 'personal_sign',
-        params: [
-          '0x2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae',
-          '0xf1B07aC6E91A423d9c3c834cc9d938E89E19334a',
-        ],
-      })
-    })
-
-    it('should validate eth address', async () => {
-      const providerMock = jest.fn()
-      providerMock.mockReturnValue(expectedSignatureHex)
-
-      await expect(
-        makeEthereumWalletSigner({ request: providerMock } as JsonRPC, '0x307aC6E91A423d9c3c834cc9d938E89E19334a'),
-      ).rejects.toThrow(TypeError)
-    })
-  })
-})

package/test/unit/utils/hex.spec.ts

@@ -1,115 +0,0 @@
-import { bytesToHex, HexString, hexToBytes, intToHex, isHexString, makeHexString } from '../../../src/utils/hex'
-
-describe('hex', () => {
-  // prettier-ignore
-  const testBytes = new Uint8Array([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff])
-  const testHex = '00112233445566778899aabbccddeeff' as HexString
-
-  describe('makeHexString', () => {
-    describe('strings', () => {
-      it('should strip prefix from valid prefixed string', () => {
-        const input = '0xC0fFEE'
-        const result = makeHexString(input)
-
-        expect(result).toBe('C0fFEE')
-      })
-
-      it('should return valid non prefixed string', () => {
-        const input = 'C0FFEE'
-        const result = makeHexString(input)
-
-        expect(result).toBe('C0FFEE')
-      })
-
-      it('should throw for other non valid strings', () => {
-        expect(() => makeHexString('')).toThrowError(TypeError)
-        expect(() => makeHexString('COFFEE')).toThrowError(TypeError)
-      })
-
-      it('should validate length if specified', () => {
-        expect(makeHexString('C0fFEE', 6)).toBe('C0fFEE')
-        expect(makeHexString('0xC0fFEE', 6)).toBe('C0fFEE')
-        expect(() => makeHexString('C0fFEE', 5)).toThrowError(TypeError)
-        expect(() => makeHexString('0xC0fFEE', 7)).toThrowError(TypeError)
-      })
-    })
-  })
-
-  describe('isHexString', () => {
-    function testCase(input: unknown, result: boolean): void {
-      it(`should ${result ? 'accept' : 'reject'} input: ${input}`, () => {
-        expect(isHexString(input)).toEqual(result)
-      })
-    }
-
-    testCase('C0FFEE', true)
-    testCase('123C0FFEE', true)
-    testCase('ZACOFFEE', false)
-    testCase('', false)
-    testCase(undefined, false)
-    testCase(null, false)
-    testCase(1, false)
-    testCase({}, false)
-    testCase([], false)
-
-    it('should validate length if specified', () => {
-      expect(isHexString('C0FFEE', 6)).toEqual(true)
-      expect(isHexString('C0FFEE', 7)).toEqual(false)
-    })
-
-    it('chequebookaddress', () => {
-      const input = '20d7855b548C71b69dA434D46187C336BDcef00F'
-      const result = isHexString(input)
-
-      expect(result).toBeTruthy()
-    })
-  })
-
-  describe('hexToBytes', () => {
-    it('converts hex to bytes', () => {
-      const input = testHex
-      const result = hexToBytes(input)
-
-      expect(result).toEqual(testBytes)
-    })
-  })
-
-  describe('bytesToHex', () => {
-    it('converts bytes to hex', () => {
-      const input = testBytes
-      const result = bytesToHex(input)
-
-      expect(result).toEqual(testHex)
-    })
-  })
-
-  describe('intToHex', () => {
-    const testValues = [
-      { value: 1, result: '1' },
-      { value: 1, result: '1', length: 1 },
-      { value: 15, length: 2, throws: TypeError },
-      { value: 16, result: '10', length: 2 },
-      { value: 16, result: '10' },
-      { value: 124, result: '7c' },
-      { value: 28721856816, result: '6aff4c130' },
-      { value: Number.MAX_SAFE_INTEGER, result: '1fffffffffffff' },
-      { value: Number.MAX_SAFE_INTEGER + 1, throws: TypeError },
-      { value: 124.1, throws: TypeError },
-      { value: 'a', throws: TypeError },
-      { value: '0', throws: TypeError },
-      { value: -1, throws: TypeError },
-    ]
-
-    testValues.forEach(({ value, result, length, throws }) => {
-      if (throws) {
-        it(`should throw error for value ${value}`, () => {
-          expect(() => intToHex(value as number, length)).toThrowError(throws)
-        })
-      } else {
-        it(`should convert value ${value} to ${result}`, () => {
-          expect(intToHex(value as number, length)).toBe(result)
-        })
-      }
-    })
-  })
-})