@ethersphere/bee-js 1.2.1 → 3.0.0

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

@@ -1,179 +0,0 @@
-import { assertAllIsDone, downloadDataMock, fetchFeedUpdateMock, MOCK_SERVER_URL, uploadFileMock } from '../nock'
-import { testBatchId, testChunkHash, testIdentity, testJsonHash } from '../../utils'
-import { Bee, ReferenceResponse } from '../../../src'
-import * as hooks from '../../../src/utils/hooks'
-
-describe('hooks', () => {
-  it('should call with request', async () => {
-    const bee = new Bee(MOCK_SERVER_URL)
-
-    const topic = bee.makeFeedTopic('some-topic')
-    fetchFeedUpdateMock(testIdentity.address, topic).reply(200, {
-      reference: testJsonHash,
-    } as ReferenceResponse)
-
-    const requestSpy = jest.fn()
-    const responseSpy = jest.fn()
-    hooks.onRequest(requestSpy)
-    hooks.onResponse(responseSpy)
-
-    const feedReader = await bee.makeFeedReader('sequence', topic, testIdentity.address)
-    const feedUpdate = await feedReader.download()
-
-    expect(feedUpdate.reference).toEqual(testJsonHash)
-
-    expect(requestSpy.mock.calls.length).toEqual(1)
-    expect(requestSpy.mock.calls[0].length).toEqual(1)
-    expect(requestSpy.mock.calls[0][0]).toEqual({
-      url: `${MOCK_SERVER_URL}feeds/${testIdentity.address}/${topic}`,
-      method: 'get',
-      params: { type: 'sequence' },
-      headers: { Accept: 'application/json, text/plain, */*' },
-    })
-
-    expect(responseSpy.mock.calls.length).toEqual(1)
-    expect(responseSpy.mock.calls[0].length).toEqual(1)
-    expect(responseSpy.mock.calls[0][0]).toEqual({
-      status: 200,
-      statusText: null,
-      headers: {
-        'content-type': 'application/json',
-      },
-      data: {
-        reference: testJsonHash,
-      },
-      request: {
-        url: `${MOCK_SERVER_URL}feeds/${testIdentity.address}/${topic}`,
-        method: 'get',
-        data: undefined,
-        params: { type: 'sequence' },
-        headers: { Accept: 'application/json, text/plain, */*', 'User-Agent': 'axios/0.21.1' },
-      },
-    })
-
-    assertAllIsDone()
-  })
-
-  it('should clear when requested', async () => {
-    const bee = new Bee(MOCK_SERVER_URL)
-
-    const topic = bee.makeFeedTopic('some-topic')
-    fetchFeedUpdateMock(testIdentity.address, topic).reply(200, {
-      reference: testJsonHash,
-    } as ReferenceResponse)
-    downloadDataMock(testChunkHash).reply(200, 'hello-world')
-
-    const requestSpy = jest.fn()
-    const responseSpy = jest.fn()
-    const requestId = hooks.onRequest(requestSpy)
-    const responseId = hooks.onResponse(responseSpy)
-
-    const feedReader = await bee.makeFeedReader('sequence', topic, testIdentity.address)
-    const feedUpdate = await feedReader.download()
-
-    expect(feedUpdate.reference).toEqual(testJsonHash)
-
-    expect(requestSpy.mock.calls.length).toEqual(1)
-    expect(requestSpy.mock.calls[0].length).toEqual(1)
-    expect(requestSpy.mock.calls[0][0]).toEqual({
-      url: `${MOCK_SERVER_URL}feeds/${testIdentity.address}/${topic}`,
-      method: 'get',
-      params: { type: 'sequence' },
-      headers: { Accept: 'application/json, text/plain, */*' },
-    })
-
-    expect(responseSpy.mock.calls.length).toEqual(1)
-    expect(responseSpy.mock.calls[0].length).toEqual(1)
-    expect(responseSpy.mock.calls[0][0]).toEqual({
-      status: 200,
-      statusText: null,
-      headers: {
-        'content-type': 'application/json',
-      },
-      data: {
-        reference: testJsonHash,
-      },
-      request: {
-        url: `${MOCK_SERVER_URL}feeds/${testIdentity.address}/${topic}`,
-        method: 'get',
-        data: undefined,
-        params: { type: 'sequence' },
-        headers: { Accept: 'application/json, text/plain, */*', 'User-Agent': 'axios/0.21.1' },
-      },
-    })
-
-    // Removing the hooks
-    hooks.clearOnRequest(requestId)
-    hooks.clearOnResponse(responseId)
-    expect((await bee.downloadData(testChunkHash)).text()).toEqual('hello-world')
-
-    // Asserting that the spy did not changed from last request
-    expect(requestSpy.mock.calls.length).toEqual(1)
-    expect(requestSpy.mock.calls[0].length).toEqual(1)
-    expect(responseSpy.mock.calls.length).toEqual(1)
-    expect(responseSpy.mock.calls[0].length).toEqual(1)
-
-    assertAllIsDone()
-  })
-
-  it('should call with request with correct headers', async () => {
-    const bee = new Bee(MOCK_SERVER_URL)
-
-    uploadFileMock(testBatchId, 'nice.txt', { encrypt: true }).reply(200, {
-      reference: testJsonHash,
-    } as ReferenceResponse)
-
-    const requestSpy = jest.fn()
-    const responseSpy = jest.fn()
-    hooks.onRequest(requestSpy)
-    hooks.onResponse(responseSpy)
-
-    const reference = await bee.uploadFile(testBatchId, 'hello world', 'nice.txt', { encrypt: true })
-
-    expect(reference).toEqual(testJsonHash)
-
-    expect(requestSpy.mock.calls.length).toEqual(1)
-    expect(requestSpy.mock.calls[0].length).toEqual(1)
-    expect(requestSpy.mock.calls[0][0]).toEqual({
-      url: `${MOCK_SERVER_URL}bzz`,
-      method: 'post',
-      data: new Uint8Array([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]),
-      params: { name: 'nice.txt' },
-      headers: {
-        Accept: 'application/json, text/plain, */*',
-        'Content-Type': 'application/x-www-form-urlencoded',
-        'swarm-encrypt': 'true',
-        'swarm-postage-batch-id': testBatchId,
-      },
-    })
-
-    expect(responseSpy.mock.calls.length).toEqual(1)
-    expect(responseSpy.mock.calls[0].length).toEqual(1)
-    expect(responseSpy.mock.calls[0][0]).toEqual({
-      status: 200,
-      statusText: null,
-      headers: {
-        'content-type': 'application/json',
-      },
-      data: {
-        reference: testJsonHash,
-      },
-      request: {
-        url: `${MOCK_SERVER_URL}bzz`,
-        method: 'post',
-        data: new ArrayBuffer(0),
-        params: { name: 'nice.txt' },
-        headers: {
-          Accept: 'application/json, text/plain, */*',
-          'Content-Type': 'application/x-www-form-urlencoded',
-          'User-Agent': 'axios/0.21.1',
-          'Content-Length': 11,
-          'swarm-encrypt': 'true',
-          'swarm-postage-batch-id': testBatchId,
-        },
-      },
-    })
-
-    assertAllIsDone()
-  })
-})

package/test/unit/utils/safe-axios.spec.ts

@@ -1,20 +0,0 @@
-import nock from 'nock'
-import { Bee } from '../../../src'
-import { setDefaultHeaders } from '../../../src/utils/safe-axios'
-
-describe('safeAxios', () => {
-  describe('setDefaultHeaders', () => {
-    it('should set default headers that are added to all requests', async () => {
-      const MOCK_SERVER_URL = 'http://localhost:12345/'
-      const scope = nock(MOCK_SERVER_URL).get('/').matchHeader('X-Custom-Header', 'some value').reply(200)
-
-      const bee = new Bee(MOCK_SERVER_URL)
-      setDefaultHeaders({ 'X-Custom-Header': 'some value' })
-      await bee.checkConnection()
-
-      if (!scope.isDone()) {
-        throw new Error('Expected call with the header was not performed!')
-      }
-    })
-  })
-})

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,292 +0,0 @@
-import { Readable } from 'stream'
-import type { BeeGenericResponse, Reference, Address, BatchId } 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'
-
-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 createRandomReadable(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
-}
-
-/**
- * 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'
-}
-
-/**
- * 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'
-}
-
-/**
- * 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'
-}
-
-/**
- * Returns a url for testing the Bee Debug API
- */
-export function beePeerDebugUrl(): string {
-  return process.env.BEE_PEER_DEBUG_API_URL || 'http://localhost:11635'
-}
-
-/**
- * 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(beeDebugUrl(), 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})`
-}
-
-export const invalidReference = '0000000000000000000000000000000000000000000000000000000000000000' as Reference
-
-export const okResponse: BeeGenericResponse = {
-  code: 200,
-  message: 'OK',
-}
-
-export const createdResponse: BeeGenericResponse = {
-  code: 201,
-  message: 'Created',
-}
-
-export const ERR_TIMEOUT = 40000
-export const BIG_FILE_TIMEOUT = 100000
-export const PSS_TIMEOUT = 120000
-export const FEED_TIMEOUT = 120000
-export const POSTAGE_BATCH_TIMEOUT = 40000
-
-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"
-}