@human-protocol/sdk 1.0.4 → 1.0.6

package/test/storage.test.ts

@@ -1,422 +0,0 @@
-import { describe, test, expect, vi, beforeAll } from 'vitest';
-import axios from 'axios';
-import crypto from 'crypto';
-import {
-  DEFAULT_ENDPOINT,
-  DEFAULT_PORT,
-  DEFAULT_PUBLIC_BUCKET,
-  DEFAULT_REGION,
-  DEFAULT_USE_SSL,
-  HttpStatus,
-  StorageCredentials,
-  StorageParams,
-} from '../src';
-import {
-  ErrorInvalidUrl,
-  ErrorStorageFileNotFound,
-  ErrorStorageFileNotUploaded,
-} from '../src/error';
-import StorageClient from '../src/storage';
-import {
-  FAKE_URL,
-  STORAGE_FAKE_BUCKET,
-  STORAGE_TEST_ACCESS_KEY,
-  STORAGE_TEST_FILE_VALUE,
-  STORAGE_TEST_FILE_VALUE_2,
-  STORAGE_TEST_SECRET_KEY,
-} from './utils/constants';
-
-// Create a Minio.Client mock for the tests
-vi.mock('minio', () => {
-  // Define a constructor for the Minio.Client mock
-  class Client {
-    getObject = vi.fn().mockImplementation(() => {
-      const read = () => {
-        return JSON.stringify({ key: STORAGE_TEST_FILE_VALUE });
-      };
-      return Promise.resolve({ read });
-    }); // getObject mock
-    putObject = vi.fn(); // putObject mock
-    bucketExists = vi.fn().mockImplementation((bucketName) => {
-      // Add conditional logic here based on the test scenario
-      if (bucketName === STORAGE_FAKE_BUCKET) {
-        return Promise.resolve(false); // Return false for fake scenario
-      } else {
-        return Promise.resolve(true); // Return true for other scenarios
-      }
-    });
-  }
-
-  // Return Minio.Client mock
-  return { Client };
-});
-
-vi.mock('axios');
-
-describe('Storage tests', () => {
-  describe('Client initialization', () => {
-    test('should set correct credentials', async () => {
-      const storageCredentials: StorageCredentials = {
-        accessKey: STORAGE_TEST_ACCESS_KEY,
-        secretKey: STORAGE_TEST_SECRET_KEY,
-      };
-
-      expect(storageCredentials.accessKey).toEqual(STORAGE_TEST_ACCESS_KEY);
-      expect(storageCredentials.secretKey).toEqual(STORAGE_TEST_SECRET_KEY);
-    });
-
-    test('should set correct params', async () => {
-      const storageParams: StorageParams = {
-        endPoint: DEFAULT_ENDPOINT,
-        port: DEFAULT_PORT,
-        useSSL: DEFAULT_USE_SSL,
-        region: DEFAULT_REGION,
-      };
-
-      expect(storageParams.endPoint).toEqual(DEFAULT_ENDPOINT);
-      expect(storageParams.port).toEqual(DEFAULT_PORT);
-      expect(storageParams.useSSL).toEqual(false);
-      expect(storageParams.region).toEqual(DEFAULT_REGION);
-    });
-
-    test('should init client with empty credentials', async () => {
-      const storageCredentials: StorageCredentials = {
-        accessKey: '',
-        secretKey: '',
-      };
-
-      const storageParams: StorageParams = {
-        endPoint: DEFAULT_ENDPOINT,
-        port: DEFAULT_PORT,
-        useSSL: DEFAULT_USE_SSL,
-      };
-
-      const storageClient = new StorageClient(
-        storageCredentials,
-        storageParams
-      );
-
-      expect(storageClient).toBeInstanceOf(StorageClient);
-    });
-
-    test('should not init client with an error', async () => {
-      // TODO: Adapt it for particular test case
-      /* vi.mock('../src/storage', () => {
-        const StorageClient = vi.fn().mockImplementation(() => {
-          throw ErrorStorageClientNotInitialized;
-        });
-      
-        return {
-          default: StorageClient
-        }
-      }) */
-      // expect(() => new StorageClient(storageCredentials, storageParams)).toThrow(ErrorStorageClientNotInitialized);
-    });
-  });
-
-  describe('Client anonymous access', () => {
-    let storageClient: StorageClient;
-
-    beforeAll(async () => {
-      const storageCredentials: StorageCredentials = {
-        accessKey: '',
-        secretKey: '',
-      };
-
-      const storageParams: StorageParams = {
-        endPoint: DEFAULT_ENDPOINT,
-        port: DEFAULT_PORT,
-        useSSL: DEFAULT_USE_SSL,
-      };
-
-      storageClient = new StorageClient(storageCredentials, storageParams);
-    });
-
-    test('should return the bucket exists', async () => {
-      const isExists = await storageClient.bucketExists(DEFAULT_PUBLIC_BUCKET);
-      expect(isExists).toEqual(true);
-    });
-
-    test('should return the bucket does not exist', async () => {
-      const isExists = await storageClient.bucketExists(STORAGE_FAKE_BUCKET);
-      expect(isExists).toEqual(false);
-    });
-
-    test('should upload the file with success', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-
-      const uploadedResults = await storageClient.uploadFiles(
-        [file],
-        DEFAULT_PUBLIC_BUCKET
-      );
-
-      const hash = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file))
-        .digest('hex');
-      const key = hash;
-
-      expect(storageClient['client'].putObject).toHaveBeenCalledWith(
-        DEFAULT_PUBLIC_BUCKET,
-        key,
-        JSON.stringify(file),
-        {
-          'Content-Type': 'application/json',
-        }
-      );
-      expect(uploadedResults[0].key).toEqual(key);
-      expect(uploadedResults[0].hash).toEqual(hash);
-    });
-
-    test('should not upload the file with an error', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-      vi.spyOn(storageClient, 'uploadFiles').mockImplementation(() => {
-        throw ErrorStorageFileNotUploaded;
-      });
-      expect(() =>
-        storageClient.uploadFiles([file], DEFAULT_PUBLIC_BUCKET)
-      ).toThrow(ErrorStorageFileNotUploaded);
-    });
-
-    test('should download the files with success', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-
-      const hash = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file))
-        .digest('hex');
-      const key = hash;
-
-      const downloadedResults = await storageClient.downloadFiles(
-        [key],
-        DEFAULT_PUBLIC_BUCKET
-      );
-
-      expect(storageClient['client'].getObject).toHaveBeenCalledWith(
-        DEFAULT_PUBLIC_BUCKET,
-        key
-      );
-      expect(downloadedResults[0].key).toEqual(key);
-      expect(downloadedResults[0].content).toEqual(file);
-    });
-
-    test('should not download the files with an error', async () => {
-      vi.spyOn(storageClient, 'downloadFiles').mockImplementation(() => {
-        throw ErrorStorageFileNotFound;
-      });
-      expect(() =>
-        storageClient.downloadFiles(
-          [STORAGE_TEST_FILE_VALUE],
-          DEFAULT_PUBLIC_BUCKET
-        )
-      ).toThrow(ErrorStorageFileNotFound);
-    });
-
-    test('should fail URL validation', async () => {
-      expect(StorageClient.downloadFileFromUrl(FAKE_URL)).rejects.toThrow(
-        ErrorInvalidUrl
-      );
-    });
-
-    test('should download the file from URL with success', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-
-      vi.spyOn(axios, 'get').mockImplementation(() =>
-        Promise.resolve({ data: file, status: HttpStatus.OK })
-      );
-
-      const hash = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file))
-        .digest('hex');
-      const url = `http://${DEFAULT_PUBLIC_BUCKET}/${hash}.json`;
-
-      const result = await StorageClient.downloadFileFromUrl(url);
-      expect(result).toEqual(file);
-    });
-
-    test('should not download the file from URL with an error', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-
-      const hash = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file))
-        .digest('hex');
-      const url = `http://${DEFAULT_PUBLIC_BUCKET}/${hash}.json`;
-
-      vi.spyOn(StorageClient, 'downloadFileFromUrl').mockImplementation(() => {
-        throw ErrorStorageFileNotFound;
-      });
-      expect(() => StorageClient.downloadFileFromUrl(url)).toThrow(
-        ErrorStorageFileNotFound
-      );
-    });
-
-    test('should return a list of objects with success', async () => {
-      const file1 = { key: STORAGE_TEST_FILE_VALUE };
-      const hash1 = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file1))
-        .digest('hex');
-      const key1 = hash1;
-
-      const file2 = { key: STORAGE_TEST_FILE_VALUE_2 };
-      const hash2 = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file2))
-        .digest('hex');
-      const key2 = hash2;
-
-      vi.spyOn(storageClient, 'listObjects').mockImplementation(() =>
-        Promise.resolve([key1, key2])
-      );
-
-      const results = await storageClient.listObjects(DEFAULT_PUBLIC_BUCKET);
-
-      expect(results[0]).toEqual(key1);
-      expect(results[1]).toEqual(key2);
-    });
-
-    test('should not return a list of objects with an error', async () => {
-      vi.spyOn(storageClient, 'listObjects').mockImplementation(() => {
-        throw new Error();
-      });
-      expect(() => storageClient.listObjects(DEFAULT_PUBLIC_BUCKET)).toThrow(
-        new Error()
-      );
-    });
-  });
-
-  describe('Client with credentials', () => {
-    let storageClient: StorageClient;
-
-    beforeAll(async () => {
-      const storageCredentials: StorageCredentials = {
-        accessKey: STORAGE_TEST_ACCESS_KEY,
-        secretKey: STORAGE_TEST_SECRET_KEY,
-      };
-
-      const storageParams: StorageParams = {
-        endPoint: DEFAULT_ENDPOINT,
-        port: DEFAULT_PORT,
-        useSSL: DEFAULT_USE_SSL,
-      };
-
-      storageClient = new StorageClient(storageCredentials, storageParams);
-    });
-
-    test('should return the bucket exists', async () => {
-      const isExists = await storageClient.bucketExists(DEFAULT_PUBLIC_BUCKET);
-      expect(isExists).toEqual(true);
-    });
-
-    test('should return the bucket does not exist', async () => {
-      const isExists = await storageClient.bucketExists(STORAGE_FAKE_BUCKET);
-      expect(isExists).toEqual(false);
-    });
-
-    test('should upload the file with success', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-
-      const uploadedResults = await storageClient.uploadFiles(
-        [file],
-        DEFAULT_PUBLIC_BUCKET
-      );
-
-      const hash = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file))
-        .digest('hex');
-      const key = hash;
-
-      expect(storageClient['client'].putObject).toHaveBeenCalledWith(
-        DEFAULT_PUBLIC_BUCKET,
-        key,
-        JSON.stringify(file),
-        {
-          'Content-Type': 'application/json',
-        }
-      );
-      expect(uploadedResults[0].key).toEqual(key);
-      expect(uploadedResults[0].hash).toEqual(hash);
-    });
-
-    test('should not upload the file with an error', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-      vi.spyOn(storageClient, 'uploadFiles').mockImplementation(() => {
-        throw ErrorStorageFileNotUploaded;
-      });
-      expect(() =>
-        storageClient.uploadFiles([file], DEFAULT_PUBLIC_BUCKET)
-      ).toThrow(ErrorStorageFileNotUploaded);
-    });
-
-    test('should download the file with success', async () => {
-      const file = { key: STORAGE_TEST_FILE_VALUE };
-
-      const hash = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file))
-        .digest('hex');
-      const key = hash;
-
-      const downloadedResults = await storageClient.downloadFiles(
-        [key],
-        DEFAULT_PUBLIC_BUCKET
-      );
-
-      expect(storageClient['client'].getObject).toHaveBeenCalledWith(
-        DEFAULT_PUBLIC_BUCKET,
-        key
-      );
-      expect(downloadedResults[0].key).toEqual(key);
-      expect(downloadedResults[0].content).toEqual(file);
-    });
-
-    test('should not download the file with an error', async () => {
-      vi.spyOn(storageClient, 'downloadFiles').mockImplementation(() => {
-        throw ErrorStorageFileNotFound;
-      });
-      expect(() =>
-        storageClient.downloadFiles(
-          [STORAGE_TEST_FILE_VALUE],
-          DEFAULT_PUBLIC_BUCKET
-        )
-      ).toThrow(ErrorStorageFileNotFound);
-    });
-
-    test('should return a list of objects with success', async () => {
-      const file1 = { key: STORAGE_TEST_FILE_VALUE };
-      const hash1 = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file1))
-        .digest('hex');
-      const key1 = hash1;
-
-      const file2 = { key: STORAGE_TEST_FILE_VALUE_2 };
-      const hash2 = crypto
-        .createHash('sha1')
-        .update(JSON.stringify(file2))
-        .digest('hex');
-      const key2 = hash2;
-
-      vi.spyOn(storageClient, 'listObjects').mockImplementation(() =>
-        Promise.resolve([key1, key2])
-      );
-
-      const results = await storageClient.listObjects(DEFAULT_PUBLIC_BUCKET);
-
-      expect(results[0]).toEqual(key1);
-      expect(results[1]).toEqual(key2);
-    });
-
-    test('should not return a list of objects with an error', async () => {
-      vi.spyOn(storageClient, 'listObjects').mockImplementation(() => {
-        throw new Error();
-      });
-      expect(() => storageClient.listObjects(DEFAULT_PUBLIC_BUCKET)).toThrow(
-        new Error()
-      );
-    });
-  });
-});

package/test/utils/constants.ts

@@ -1,67 +0,0 @@
-import { ChainId } from '../../src/enums';
-
-export const DEFAULT_HMTOKEN_ADDR =
-  '0x5FbDB2315678afecb367f032d93F642f64180aa3';
-
-export const DEFAULT_STAKING_ADDR =
-  '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0';
-
-export const DEFAULT_GAS_PAYER_ADDR =
-  '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-export const DEFAULT_GAS_PAYER_PRIVKEY =
-  'ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
-
-export const REPUTATION_ORACLE_ADDR =
-  '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
-export const REPUTATION_ORACLE_PRIVKEY =
-  '59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d';
-
-export const TRUSTED_OPERATOR1_ADDR =
-  '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC';
-export const TRUSTED_OPERATOR1_PRIVKEY =
-  '5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a';
-
-export const TRUSTED_OPERATOR2_ADDR =
-  '0x90F79bf6EB2c4f870365E785982E1f101E93b906';
-
-export const WORKER1_ADDR = '0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65';
-export const WORKER2_ADDR = '0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc';
-export const WORKER3_ADDR = '0x976EA74026E726554dB657fA54763abd0C3a0aa9';
-
-export const NOT_TRUSTED_OPERATOR_PRIVKEY =
-  '5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365b';
-
-export const STORAGE_TEST_ACCESS_KEY = 'my-access-key';
-export const STORAGE_TEST_SECRET_KEY = 'my-secret-key';
-export const STORAGE_FAKE_BUCKET = 'fake-bucket';
-export const STORAGE_TEST_FILE_VALUE = 'value';
-export const STORAGE_TEST_FILE_VALUE_2 = 'another value';
-export const FAKE_URL = 'fakeUrl';
-export const FAKE_NETWORK_NAME = 'fake_network';
-export const VALID_URL = 'https://www.humanprotocol.org';
-
-/**
- * @constant Default network parameters
- */
-export const FAKE_NETWORK = {
-  chainId: ChainId.LOCALHOST,
-  title: FAKE_NETWORK_NAME,
-  scanUrl: '',
-  factoryAddress: '0x0000000000000000000000000000000000000000',
-  hmtAddress: '0x0000000000000000000000000000000000000000',
-  stakingAddress: '0x0000000000000000000000000000000000000000',
-  kvstoreAddress: '0x0000000000000000000000000000000000000000',
-  subgraphUrl: 'http://fake.url',
-  oldSubgraphUrl: 'http://fake.url',
-  oldFactoryAddress: 'http://fake.url',
-};
-
-export const FAKE_TRANSACTION_HASH =
-  '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
-export const FAKE_TRANSACTION_CONFIRMATIONS = 1;
-export const FAKE_BLOCK_NUMBER = '1234';
-export const FAKE_ADDRESS = '0x1234567890abcdef';
-export const FAKE_AMOUNT = 100;
-export const FAKE_NEGATIVE_AMOUNT = -100;
-export const FAKE_HASH =
-  '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';