@ethersphere/bee-js 2.1.0 → 3.2.0

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

@@ -1,32 +0,0 @@
-/* eslint @typescript-eslint/no-empty-function: 0 */
-import { NumberString } from '../../../src/types'
-import { isInteger } from '../../../src/utils/type'
-
-describe('type', () => {
-  describe('isInteger', () => {
-    const wrongValues = [
-      () => {},
-      Number.MAX_SAFE_INTEGER + 1,
-      Number.MIN_SAFE_INTEGER - 1,
-      5.000000000000001,
-      false,
-      true,
-      Infinity,
-      NaN,
-      [1],
-    ]
-    const correctValues = [5, 0, '10', 5.0000000000000001, '-1']
-
-    wrongValues.forEach((v: unknown | NumberString) =>
-      test(`should return false for value  ${v}`, () => {
-        expect(isInteger(v)).toEqual(false)
-      }),
-    )
-
-    correctValues.forEach((v: unknown | NumberString) =>
-      test(`should return true for value  ${v}`, () => {
-        expect(isInteger(v)).toEqual(true)
-      }),
-    )
-  })
-})

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

@@ -1,102 +0,0 @@
-import { Bytes, makeBytes } from '../../../src/utils/bytes'
-import { HexString, hexToBytes } from '../../../src/utils/hex'
-import { readUint64BigEndian, writeUint64BigEndian, writeUint64LittleEndian } from '../../../src/utils/uint64'
-
-describe('uint64', () => {
-  describe('little endian', () => {
-    test('zero', () => {
-      const uint64 = writeUint64LittleEndian(0)
-      const zero = makeBytes(8)
-
-      expect(uint64).toEqual(zero)
-    })
-
-    test('one', () => {
-      const uint64 = writeUint64LittleEndian(1)
-      const one = hexToBytes('0100000000000000' as HexString)
-
-      expect(uint64).toEqual(one)
-    })
-
-    test('deadbeef', () => {
-      const uint64 = writeUint64LittleEndian(0xdeadbeef)
-      const deadbeef = hexToBytes('efbeadde00000000' as HexString)
-
-      expect(uint64).toEqual(deadbeef)
-    })
-  })
-
-  describe('big endian', () => {
-    describe('write', () => {
-      test('zero', () => {
-        const uint64 = writeUint64BigEndian(0)
-        const zero = makeBytes(8)
-
-        expect(uint64).toEqual(zero)
-      })
-
-      test('one', () => {
-        const uint64 = writeUint64BigEndian(1)
-        const one = hexToBytes('0000000000000001' as HexString)
-
-        expect(uint64).toEqual(one)
-      })
-
-      test('deadbeef', () => {
-        const uint64 = writeUint64BigEndian(0xdeadbeef)
-        const deadbeef = hexToBytes('00000000deadbeef' as HexString)
-
-        expect(uint64).toEqual(deadbeef)
-      })
-    })
-
-    describe('read', () => {
-      test('zero', () => {
-        const zero = makeBytes(8)
-        const value = readUint64BigEndian(zero)
-
-        expect(value).toEqual(0)
-      })
-
-      test('one', () => {
-        const one = hexToBytes('0000000000000001' as HexString) as Bytes<8>
-        const value = readUint64BigEndian(one)
-
-        expect(value).toEqual(1)
-      })
-
-      test('deadbeef', () => {
-        const deadbeef = hexToBytes('00000000deadbeef' as HexString) as Bytes<8>
-        const value = readUint64BigEndian(deadbeef)
-
-        expect(value).toEqual(0xdeadbeef)
-      })
-    })
-
-    describe('read and write', () => {
-      test('zero', () => {
-        const zero = makeBytes(8)
-        const num = readUint64BigEndian(zero)
-        const value = writeUint64BigEndian(num)
-
-        expect(value).toEqual(zero)
-      })
-
-      test('one', () => {
-        const one = hexToBytes('0000000000000001' as HexString) as Bytes<8>
-        const num = readUint64BigEndian(one)
-        const value = writeUint64BigEndian(num)
-
-        expect(value).toEqual(one)
-      })
-
-      test('deadbeef', () => {
-        const deadbeef = hexToBytes('00000000deadbeef' as HexString) as Bytes<8>
-        const num = readUint64BigEndian(deadbeef)
-        const value = writeUint64BigEndian(num)
-
-        expect(value).toEqual(deadbeef)
-      })
-    })
-  })
-})

package/test/utils.ts

@@ -1,426 +0,0 @@
-import { Readable } from 'stream'
-import ky from 'ky-universal'
-import { ReadableStream } from 'web-streams-polyfill/ponyfill'
-
-import type { Ky, BeeGenericResponse, Reference, Address, BatchId, DebugPostageBatch } from '../src/types'
-import { bytesToHex, HexString } from '../src/utils/hex'
-import { deleteChunkFromLocalStorage } from '../src/modules/debug/chunk'
-import { BeeResponseError } from '../src'
-import { ChunkAddress } from '../src/chunk/cac'
-import { assertBytes } from '../src/utils/bytes'
-import * as stamps from '../src/modules/debug/stamps'
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    interface Matchers<R> {
-      toBeHashReference(): R
-      toBeBeeResponse(expectedStatusCode: number): R
-      toBeOneOf(el: unknown[]): R
-      toBeType(type: string): R
-      toBeNumberString(): R
-    }
-  }
-}
-
-/**
- * Load common own Jest Matchers which can be used to check particular return values.
- */
-export function commonMatchers(): void {
-  expect.extend({
-    toBeHashReference(received: string) {
-      const result = {
-        pass: false,
-        message: () => 'Given input is not a Swarm hash reference',
-      }
-
-      if (typeof received === 'string' && /^[0-9a-fA-F]{64}$/.test(received)) {
-        result.pass = true
-        result.message = () => 'Given string is semantically valid Swarm hash reference'
-      }
-
-      return result
-    },
-    toBeBeeResponse(received: BeeGenericResponse, expectedStatusCode: number) {
-      const result = {
-        pass: false,
-        message: () =>
-          `Bee response does not have status code ${expectedStatusCode}. Got: ${received.code}\nResponse message: ${received.message}`,
-      }
-
-      if (received.code === expectedStatusCode) {
-        result.pass = true
-        result.message = () => 'Bee response meets with its requirements'
-      }
-
-      return result
-    },
-    toBeOneOf(received, argument) {
-      const validValues = Array.isArray(argument) ? argument : [argument]
-      let containsValidValue = false
-
-      for (const validValue of validValues) {
-        try {
-          expect(received).toEqual(validValue)
-          containsValidValue = true
-          // eslint-disable-next-line no-empty
-        } catch (e) {}
-      }
-
-      if (containsValidValue) {
-        return {
-          message: () => `expected ${JSON.stringify(received)} not to be one of [${validValues.join(', ')}]`,
-          pass: true,
-        }
-      }
-
-      return {
-        message: () => `expected ${JSON.stringify(received)} to be one of [${validValues.join(', ')}]`,
-        pass: false,
-      }
-    },
-    toBeType(received, argument) {
-      const initialType = typeof received
-      const isArray = Array.isArray(received) ? 'array' : initialType
-      const type = initialType === 'object' ? isArray : initialType
-
-      return type === argument
-        ? {
-            message: () => `expected ${received} to be type ${argument}`,
-            pass: true,
-          }
-        : {
-            message: () => `expected ${received} to be type ${argument}`,
-            pass: false,
-          }
-    },
-    toBeNumberString(received) {
-      const message = () => `expected ${received} to be a number in a string type`
-
-      return /^-?(0|[1-9][0-9]*)$/g.test(received)
-        ? {
-            message,
-            pass: true,
-          }
-        : {
-            message,
-            pass: false,
-          }
-    },
-  })
-}
-
-/**
- * Sleep for N miliseconds
- *
- * @param ms Number of miliseconds to sleep
- */
-export async function sleep(ms: number): Promise<void> {
-  return new Promise<void>(resolve => setTimeout(() => resolve(), ms))
-}
-
-export function createRandomNodeReadable(totalSize: number, chunkSize = 1000): Readable {
-  if (totalSize % chunkSize !== 0) {
-    throw new Error(`totalSize ${totalSize} is not dividable without remainder by chunkSize ${chunkSize}`)
-  }
-
-  const stream = new Readable()
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  stream._read = (): void => {}
-
-  for (let i = 0; i < totalSize / chunkSize; i++) {
-    stream.push(randomByteArray(chunkSize))
-  }
-
-  stream.push(null)
-
-  return stream
-}
-
-export function createReadableStream(iterable: Iterable<Uint8Array>): ReadableStream {
-  const iter = iterable[Symbol.iterator]()
-
-  return new ReadableStream({
-    async pull(controller) {
-      const result = iter.next()
-
-      if (result.done) {
-        controller.close()
-
-        return
-      }
-
-      controller.enqueue(result.value)
-    },
-  })
-}
-
-/**
- * Lehmer random number generator with seed (minstd_rand in C++11)
- * !!! Very fast but not well distributed pseudo-random function !!!
- *
- * @param seed Seed for the pseudo-random generator
- */
-function lrng(seed: number): () => number {
-  return (): number => ((2 ** 31 - 1) & (seed = Math.imul(48271, seed))) / 2 ** 31
-}
-
-/**
- * Utility function for generating random Buffer
- * !!! IT IS NOT CRYPTO SAFE !!!
- * For that use `crypto.randomBytes()`
- *
- * @param length Number of bytes to generate
- * @param seed Seed for the pseudo-random generator
- */
-export function randomByteArray(length: number, seed = 500): Uint8Array {
-  const rand = lrng(seed)
-  const buf = new Uint8Array(length)
-
-  for (let i = 0; i < length; ++i) {
-    buf[i] = (rand() * 0xff) << 0
-  }
-
-  return buf
-}
-
-/**
- * Returns a url for testing the Bee public API
- */
-export function beeUrl(): string {
-  return process.env.BEE_API_URL || 'http://localhost:1633'
-}
-
-export function beeKy(): Ky {
-  return ky.create({ prefixUrl: beeUrl(), timeout: false })
-}
-
-/**
- * Returns a url of another peer for testing the Bee public API
- */
-export function beePeerUrl(): string {
-  return process.env.BEE_PEER_API_URL || 'http://localhost:11633'
-}
-
-export function beePeerKy(): Ky {
-  return ky.create({ prefixUrl: beePeerUrl(), timeout: false })
-}
-
-/**
- * Helper function that create monster batch for all the tests.
- * There is semaphore mechanism that allows only creation of one batch across all the
- * parallel running tests that have to wait until it is created.
- */
-export function getPostageBatch(url = beeDebugUrl()): BatchId {
-  let stamp: BatchId
-
-  switch (url) {
-    case beeDebugUrl():
-      stamp = process.env.BEE_POSTAGE as BatchId
-      break
-    case beePeerDebugUrl():
-      stamp = process.env.BEE_PEER_POSTAGE as BatchId
-      break
-    default:
-      throw new Error('Unknown URL ' + url)
-  }
-
-  if (!stamp) {
-    throw new Error('There is no postage stamp configured for URL ' + url)
-  }
-
-  return stamp
-}
-
-/**
- * Returns a url for testing the Bee Debug API
- */
-export function beeDebugUrl(): string {
-  return process.env.BEE_DEBUG_API_URL || 'http://localhost:1635'
-}
-
-export function beeDebugKy(): Ky {
-  return ky.create({ prefixUrl: beeDebugUrl(), timeout: false })
-}
-
-/**
- * Returns a url for testing the Bee Debug API
- */
-export function beePeerDebugUrl(): string {
-  return process.env.BEE_PEER_DEBUG_API_URL || 'http://localhost:11635'
-}
-
-export function beePeerDebugKy(): Ky {
-  return ky.create({ prefixUrl: beePeerDebugUrl(), timeout: false })
-}
-
-/**
- * Try to delete a chunk from local storage, ignoring all errors
- *
- * @param address  Swarm address of chunk
- */
-export async function tryDeleteChunkFromLocalStorage(address: string | ChunkAddress): Promise<void> {
-  if (typeof address !== 'string') {
-    assertBytes(address, 32)
-    address = bytesToHex(address)
-  }
-
-  try {
-    await deleteChunkFromLocalStorage(beeDebugKy(), address)
-  } catch (e) {
-    // ignore not found errors
-    if (e instanceof BeeResponseError && e.status === 404) {
-      return
-    }
-    throw e
-  }
-}
-
-/**
- * Formatting utility for displaying long strings like hexstrings.
- *
- * @param inputStr
- * @param len
- */
-export function shorten(inputStr: unknown, len = 17): string {
-  const str = typeof inputStr === 'string' ? inputStr : (inputStr as string).toString()
-
-  if (str.length <= len) {
-    return str
-  }
-
-  return `${str.slice(0, 6)}...${str.slice(-6)} (length: ${str.length})`
-}
-
-async function timeout(ms: number, message = 'Execution reached timeout!'): Promise<Error> {
-  await sleep(ms)
-  throw new Error(message)
-}
-
-export async function waitForBatchToBeUsable(batchId: string, pollingInterval = 200): Promise<void> {
-  await Promise.race([
-    timeout(USABLE_TIMEOUT, 'Awaiting of usable postage batch timed out!'),
-    async () => {
-      let stamp
-
-      do {
-        await sleep(pollingInterval)
-        stamp = await stamps.getPostageBatch(beeDebugKy(), batchId as BatchId)
-      } while (!stamp.usable)
-    },
-  ])
-}
-
-const DEFAULT_BATCH_AMOUNT = '1'
-const DEFAULT_BATCH_DEPTH = 17
-
-/**
- * Returns already existing batch or will create one.
- *
- * If some specification is passed then it is guaranteed that the batch will have this property(ies)
- *
- * @param amount
- * @param depth
- * @param immutable
- */
-export async function getOrCreatePostageBatch(
-  amount?: string,
-  depth?: number,
-  immutable?: boolean,
-): Promise<DebugPostageBatch> {
-  // Non-usable stamps are ignored by Bee
-  const allUsableStamps = (await stamps.getAllPostageBatches(beeDebugKy())).filter(stamp => stamp.usable)
-
-  if (allUsableStamps.length === 0) {
-    const batchId = await stamps.createPostageBatch(
-      beeDebugKy(),
-      amount ?? DEFAULT_BATCH_AMOUNT,
-      depth ?? DEFAULT_BATCH_DEPTH,
-    )
-
-    await waitForBatchToBeUsable(batchId)
-
-    return stamps.getPostageBatch(beeDebugKy(), batchId)
-  }
-
-  // User does not want any specific batch, lets give him the first one
-  if (amount === undefined && depth === undefined && immutable === undefined) {
-    return allUsableStamps[0]
-  }
-
-  // User wants some specific batch
-  for (const stamp of allUsableStamps) {
-    let meetingAllCriteria = false
-
-    if (amount !== undefined) {
-      meetingAllCriteria = amount === stamp.amount
-    } else {
-      meetingAllCriteria = true
-    }
-
-    if (depth !== undefined) {
-      meetingAllCriteria = meetingAllCriteria && depth === stamp.depth
-    }
-
-    if (immutable !== undefined) {
-      meetingAllCriteria = meetingAllCriteria && immutable === stamp.immutableFlag
-    }
-
-    if (meetingAllCriteria) {
-      return stamp
-    }
-  }
-
-  // No stamp meeting the criteria was found ==> we need to create a new one
-  const batchId = await stamps.createPostageBatch(
-    beeDebugKy(),
-    amount ?? DEFAULT_BATCH_AMOUNT,
-    depth ?? DEFAULT_BATCH_DEPTH,
-  )
-
-  await waitForBatchToBeUsable(batchId)
-
-  return stamps.getPostageBatch(beeDebugKy(), batchId)
-}
-
-export function makeTestTarget(target: string): string {
-  return target.slice(0, 2)
-}
-
-export const invalidReference = '0000000000000000000000000000000000000000000000000000000000000000' as Reference
-
-export const okResponse: BeeGenericResponse = {
-  code: 200,
-  message: 'OK',
-}
-
-export const createdResponse: BeeGenericResponse = {
-  code: 201,
-  message: 'Created',
-}
-
-const USABLE_TIMEOUT = 7_000
-export const ERR_TIMEOUT = 40_000
-export const BIG_FILE_TIMEOUT = 100_000
-export const PSS_TIMEOUT = 120_000
-export const FEED_TIMEOUT = 120_000
-export const BLOCKCHAIN_TRANSACTION_TIMEOUT = 40_000
-
-export const testChunkPayload = new Uint8Array([1, 2, 3])
-// span is the payload length encoded as uint64 little endian
-export const testChunkSpan = new Uint8Array([testChunkPayload.length, 0, 0, 0, 0, 0, 0, 0])
-export const testChunkData = new Uint8Array([...testChunkSpan, ...testChunkPayload])
-// the hash is hardcoded because we would need the bmt hasher otherwise
-export const testChunkHash = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338' as Reference
-export const testAddress = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338' as Address
-export const testBatchId = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338' as BatchId
-
-export const testJsonPayload = [{ some: 'object' }]
-export const testJsonStringPayload = JSON.stringify(testJsonPayload)
-export const testJsonHash = '872a858115b8bee4408b1427b49e472883fdc2512d5a8f2d428b97ecc8f7ccfa'
-
-export const testIdentity = {
-  privateKey: '634fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd' as HexString,
-  publicKey: '03c32bb011339667a487b6c1c35061f15f7edc36aa9a0f8648aba07a4b8bd741b4' as HexString,
-  address: '8d3766440f0d7b949a5e32995d09619a7f86e632' as HexString,
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "include": ["src"],
-  "compilerOptions": {
-    "alwaysStrict": true,
-    "target": "ES6",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "moduleResolution": "node",
-    "module": "commonjs",
-    "strict": true,
-    "resolveJsonModule": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "typeRoots": ["./src/types", "node_modules/@types"],
-    "rootDirs": ["src"],
-    "outDir": "dist"
-  },
-}

package/tsconfig.test.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": [
-    "src",
-    "test",
-    "jest.config.ts"
-  ],
-  "compilerOptions": {
-    "noEmit": true
-  }
-}

package/typedoc.json

@@ -1,7 +0,0 @@
-{
-  "entryPoints": ["./src/index.ts"],
-  "readme": "none",
-  "logLevel": "Verbose",
-  "excludePrivate": true,
-  "out": "docs"
-}