@ethersphere/bee-js 4.1.0 → 5.0.0

package/dist/mjs/test/utils.js

@@ -1,458 +0,0 @@
-var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
-  }
-
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-
-import { Readable } from 'stream';
-import { ReadableStream as ReadableStreamPolyfill } from 'web-streams-polyfill';
-import ky from 'ky-universal';
-import { bytesToHex } from "../src/utils/hex.js";
-import { deleteChunkFromLocalStorage } from "../src/modules/debug/chunk.js";
-import { BeeResponseError } from "../src/index.js";
-import { assertBytes } from "../src/utils/bytes.js";
-import * as stamps from "../src/modules/debug/stamps.js";
-/**
- * Load common own Jest Matchers which can be used to check particular return values.
- */
-
-export function commonMatchers() {
-  expect.extend({
-    toBeHashReference(received) {
-      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, expectedStatusCode) {
-      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 function sleep(ms) {
-  return __awaiter(this, void 0, void 0, function* () {
-    return new Promise(resolve => setTimeout(() => resolve(), ms));
-  });
-}
-/**
- * Helper function that reads whole content of ReadableStream
- * @param stream
- */
-
-export function readWholeUint8ArrayReadableStream(stream) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const reader = stream.getReader();
-    let buff = [];
-    let readResult;
-
-    do {
-      readResult = yield reader.read();
-      if (readResult.value) buff = [...buff, ...readResult.value];
-    } while (!readResult.done);
-
-    return new Uint8Array(buff);
-  });
-}
-export function createRandomNodeReadable(totalSize, chunkSize = 1000) {
-  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 = () => {};
-
-  for (let i = 0; i < totalSize / chunkSize; i++) {
-    stream.push(randomByteArray(chunkSize));
-  }
-
-  stream.push(null);
-  return stream;
-}
-export function createReadableStream(iterable) {
-  const iter = iterable[Symbol.iterator]();
-  return new ReadableStreamPolyfill({
-    pull(controller) {
-      return __awaiter(this, void 0, void 0, function* () {
-        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) {
-  return () => (Math.pow(2, 31) - 1 & (seed = Math.imul(48271, seed))) / Math.pow(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, seed = 500) {
-  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() {
-  return process.env.BEE_API_URL || 'http://127.0.0.1:1633';
-}
-export function beeKy() {
-  return ky.create({
-    prefixUrl: beeUrl(),
-    timeout: false
-  });
-}
-/**
- * Returns a url of another peer for testing the Bee public API
- */
-
-export function beePeerUrl() {
-  return process.env.BEE_PEER_API_URL || 'http://127.0.0.1:11633';
-}
-export function beePeerKy() {
-  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()) {
-  let stamp;
-
-  switch (url) {
-    case beeDebugUrl():
-      stamp = process.env.BEE_POSTAGE;
-      break;
-
-    case beePeerDebugUrl():
-      stamp = process.env.BEE_PEER_POSTAGE;
-      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() {
-  return process.env.BEE_DEBUG_API_URL || 'http://127.0.0.1:1635';
-}
-export function beeDebugKy() {
-  return ky.create({
-    prefixUrl: beeDebugUrl(),
-    timeout: false
-  });
-}
-/**
- * Returns a url for testing the Bee Debug API
- */
-
-export function beePeerDebugUrl() {
-  return process.env.BEE_PEER_DEBUG_API_URL || 'http://127.0.0.1:11635';
-}
-export function beePeerDebugKy() {
-  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 function tryDeleteChunkFromLocalStorage(address) {
-  return __awaiter(this, void 0, void 0, function* () {
-    if (typeof address !== 'string') {
-      assertBytes(address, 32);
-      address = bytesToHex(address);
-    }
-
-    try {
-      yield 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, len = 17) {
-  const str = typeof inputStr === 'string' ? inputStr : inputStr.toString();
-
-  if (str.length <= len) {
-    return str;
-  }
-
-  return `${str.slice(0, 6)}...${str.slice(-6)} (length: ${str.length})`;
-}
-
-function timeout(ms, message = 'Execution reached timeout!') {
-  return __awaiter(this, void 0, void 0, function* () {
-    yield sleep(ms);
-    throw new Error(message);
-  });
-}
-
-export function waitForBatchToBeUsable(batchId, pollingInterval = 200) {
-  return __awaiter(this, void 0, void 0, function* () {
-    yield Promise.race([timeout(USABLE_TIMEOUT, 'Awaiting of usable postage batch timed out!'), () => __awaiter(this, void 0, void 0, function* () {
-      let stamp;
-
-      do {
-        yield sleep(pollingInterval);
-        stamp = yield stamps.getPostageBatch(beeDebugKy(), 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 function getOrCreatePostageBatch(amount, depth, immutable) {
-  return __awaiter(this, void 0, void 0, function* () {
-    // Non-usable stamps are ignored by Bee
-    const allUsableStamps = (yield stamps.getAllPostageBatches(beeDebugKy())).filter(stamp => stamp.usable);
-
-    if (allUsableStamps.length === 0) {
-      const batchId = yield stamps.createPostageBatch(beeDebugKy(), amount !== null && amount !== void 0 ? amount : DEFAULT_BATCH_AMOUNT, depth !== null && depth !== void 0 ? depth : DEFAULT_BATCH_DEPTH);
-      yield 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 = yield stamps.createPostageBatch(beeDebugKy(), amount !== null && amount !== void 0 ? amount : DEFAULT_BATCH_AMOUNT, depth !== null && depth !== void 0 ? depth : DEFAULT_BATCH_DEPTH);
-    yield waitForBatchToBeUsable(batchId);
-    return stamps.getPostageBatch(beeDebugKy(), batchId);
-  });
-}
-export function makeTestTarget(target) {
-  return target.slice(0, 2);
-}
-export const invalidReference = '0000000000000000000000000000000000000000000000000000000000000000';
-export const okResponse = {
-  code: 200,
-  message: 'OK'
-};
-export const createdResponse = {
-  code: 201,
-  message: 'Created'
-};
-const USABLE_TIMEOUT = 7000;
-export const ERR_TIMEOUT = 40000;
-export const BIG_FILE_TIMEOUT = 100000;
-export const PSS_TIMEOUT = 120000;
-export const FEED_TIMEOUT = 120000;
-export const BLOCKCHAIN_TRANSACTION_TIMEOUT = 40000;
-export const WAITING_USABLE_STAMP_TIMEOUT = 130000;
-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';
-export const testAddress = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338';
-export const testBatchId = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338';
-export const testJsonPayload = [{
-  some: 'object'
-}];
-export const testJsonStringPayload = JSON.stringify(testJsonPayload);
-export const testJsonHash = '872a858115b8bee4408b1427b49e472883fdc2512d5a8f2d428b97ecc8f7ccfa';
-export const testJsonCid = 'bah5acgzaq4vilaivxc7oiqelcqt3jhshfcb73qsrfvni6lkcrol6zshxzt5a';
-export const testJsonEns = 'testing.eth';
-export const testIdentity = {
-  privateKey: '634fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd',
-  publicKey: '03c32bb011339667a487b6c1c35061f15f7edc36aa9a0f8648aba07a4b8bd741b4',
-  address: '8d3766440f0d7b949a5e32995d09619a7f86e632'
-};

package/dist/types/test/utils.d.ts

@@ -1,119 +0,0 @@
-/// <reference types="node" />
-import { Readable } from 'stream';
-import type { Ky, BeeGenericResponse, Reference, Address, BatchId, PostageBatch, PlainBytesReference } from '../src/types';
-import { HexString } from '../src/utils/hex';
-declare global {
-    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 declare function commonMatchers(): void;
-/**
- * Sleep for N miliseconds
- *
- * @param ms Number of miliseconds to sleep
- */
-export declare function sleep(ms: number): Promise<void>;
-/**
- * Helper function that reads whole content of ReadableStream
- * @param stream
- */
-export declare function readWholeUint8ArrayReadableStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
-export declare function createRandomNodeReadable(totalSize: number, chunkSize?: number): Readable;
-export declare function createReadableStream(iterable: Iterable<Uint8Array>): ReadableStream;
-/**
- * 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 declare function randomByteArray(length: number, seed?: number): Uint8Array;
-/**
- * Returns a url for testing the Bee public API
- */
-export declare function beeUrl(): string;
-export declare function beeKy(): Ky;
-/**
- * Returns a url of another peer for testing the Bee public API
- */
-export declare function beePeerUrl(): string;
-export declare function beePeerKy(): Ky;
-/**
- * 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 declare function getPostageBatch(url?: string): BatchId;
-/**
- * Returns a url for testing the Bee Debug API
- */
-export declare function beeDebugUrl(): string;
-export declare function beeDebugKy(): Ky;
-/**
- * Returns a url for testing the Bee Debug API
- */
-export declare function beePeerDebugUrl(): string;
-export declare function beePeerDebugKy(): Ky;
-/**
- * Try to delete a chunk from local storage, ignoring all errors
- *
- * @param address  Swarm address of chunk
- */
-export declare function tryDeleteChunkFromLocalStorage(address: string | PlainBytesReference): Promise<void>;
-/**
- * Formatting utility for displaying long strings like hexstrings.
- *
- * @param inputStr
- * @param len
- */
-export declare function shorten(inputStr: unknown, len?: number): string;
-export declare function waitForBatchToBeUsable(batchId: string, pollingInterval?: number): Promise<void>;
-/**
- * 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 declare function getOrCreatePostageBatch(amount?: string, depth?: number, immutable?: boolean): Promise<PostageBatch>;
-export declare function makeTestTarget(target: string): string;
-export declare const invalidReference: Reference;
-export declare const okResponse: BeeGenericResponse;
-export declare const createdResponse: BeeGenericResponse;
-export declare const ERR_TIMEOUT = 40000;
-export declare const BIG_FILE_TIMEOUT = 100000;
-export declare const PSS_TIMEOUT = 120000;
-export declare const FEED_TIMEOUT = 120000;
-export declare const BLOCKCHAIN_TRANSACTION_TIMEOUT = 40000;
-export declare const WAITING_USABLE_STAMP_TIMEOUT = 130000;
-export declare const testChunkPayload: Uint8Array;
-export declare const testChunkSpan: Uint8Array;
-export declare const testChunkData: Uint8Array;
-export declare const testChunkHash: Reference;
-export declare const testAddress: Address;
-export declare const testBatchId: BatchId;
-export declare const testJsonPayload: {
-    some: string;
-}[];
-export declare const testJsonStringPayload: string;
-export declare const testJsonHash = "872a858115b8bee4408b1427b49e472883fdc2512d5a8f2d428b97ecc8f7ccfa";
-export declare const testJsonCid = "bah5acgzaq4vilaivxc7oiqelcqt3jhshfcb73qsrfvni6lkcrol6zshxzt5a";
-export declare const testJsonEns = "testing.eth";
-export declare const testIdentity: {
-    privateKey: HexString<number>;
-    publicKey: HexString<number>;
-    address: HexString<number>;
-};