@human-protocol/sdk 1.0.2 → 1.0.3

package/test/storage.test.ts

@@ -0,0 +1,422 @@
+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,8 +1,10 @@
+import { ChainId } from '../../src/enums';
+
 export const DEFAULT_HMTOKEN_ADDR =
   '0x5FbDB2315678afecb367f032d93F642f64180aa3';
 
 export const DEFAULT_STAKING_ADDR =
-  '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512';
+  '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0';
 
 export const DEFAULT_GAS_PAYER_ADDR =
   '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
@@ -28,3 +30,38 @@ 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';

package/example/simple-existing-job.ts

@@ -1,86 +0,0 @@
-/* eslint-disable no-console */
-import { Job } from '../src';
-import {
-  DEFAULT_GAS_PAYER_PRIVKEY,
-  DEFAULT_HMTOKEN_ADDR,
-  REPUTATION_ORACLE_PRIVKEY,
-  WORKER1_ADDR,
-  WORKER2_ADDR,
-} from '../test/utils/constants';
-import { manifest } from '../test/utils/manifest';
-import * as dotenv from 'dotenv';
-
-dotenv.config();
-
-const main = async () => {
-  // Create job object
-  const newJob = new Job({
-    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
-    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
-    manifest: manifest,
-    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
-    logLevel: 'debug',
-  });
-
-  // Initialize new job object
-  await newJob.initialize();
-
-  // Launch the job
-  await newJob.launch();
-
-  // Access the existing job
-  const job = new Job({
-    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
-    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
-    manifest: manifest,
-    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
-    factoryAddr: newJob.contractData?.factoryAddr,
-    escrowAddr: newJob.contractData?.escrowAddr,
-    storageAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
-    storageSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    storageEndpoint: process.env.AWS_ENDPOINT,
-    storageBucket: process.env.AWS_BUCKET,
-    storagePublicBucket: process.env.AWS_PUBLIC_BUCKET,
-    logLevel: 'debug',
-  });
-
-  // Initialize the job object
-  await job.initialize();
-
-  // Setup the job
-  await job.setup();
-
-  console.log(
-    `Status: ${await job.status()}, Balance: ${(
-      await job.balance()
-    )?.toString()}`
-  );
-
-  // Bulk payout workers
-  await job.bulkPayout(
-    [
-      {
-        address: WORKER1_ADDR,
-        amount: 70,
-      },
-      {
-        address: WORKER2_ADDR,
-        amount: 30,
-      },
-    ],
-    {
-      result: 'result',
-    }
-  );
-
-  // Complete the job
-  await job.complete();
-
-  console.log(
-    `Status: ${await job.status()}, Balance: ${(
-      await job.balance()
-    )?.toString()}`
-  );
-};
-
-main();

package/example/simple-new-job-public.ts

@@ -1,74 +0,0 @@
-/* eslint-disable no-console */
-import { Job } from '../src';
-import {
-  DEFAULT_GAS_PAYER_PRIVKEY,
-  DEFAULT_HMTOKEN_ADDR,
-  REPUTATION_ORACLE_PRIVKEY,
-  WORKER1_ADDR,
-  WORKER2_ADDR,
-} from '../test/utils/constants';
-import { manifest } from '../test/utils/manifest';
-import * as dotenv from 'dotenv';
-
-dotenv.config();
-
-const main = async () => {
-  // Create job object
-  const job = new Job({
-    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
-    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
-    manifest: manifest,
-    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
-    storageAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
-    storageSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    storageEndpoint: process.env.AWS_ENDPOINT,
-    storageBucket: process.env.AWS_BUCKET,
-    storagePublicBucket: process.env.AWS_PUBLIC_BUCKET,
-    logLevel: 'debug',
-  });
-
-  // Initialize new job
-  await job.initialize();
-
-  // Launch the job
-  await job.launch();
-
-  // Setup the job
-  await job.setup();
-
-  console.log(
-    `Status: ${await job.status()}, Balance: ${(
-      await job.balance()
-    )?.toString()}`
-  );
-
-  // Bulk payout workers
-  await job.bulkPayout(
-    [
-      {
-        address: WORKER1_ADDR,
-        amount: 70,
-      },
-      {
-        address: WORKER2_ADDR,
-        amount: 30,
-      },
-    ],
-    {
-      result: 'result',
-    },
-    false,
-    true
-  );
-
-  // Complete the job
-  await job.complete();
-
-  console.log(
-    `Status: ${await job.status()}, Balance: ${(
-      await job.balance()
-    )?.toString()}`
-  );
-};
-
-main();

package/example/simple-new-job.ts

@@ -1,72 +0,0 @@
-/* eslint-disable no-console */
-import { Job } from '../src';
-import {
-  DEFAULT_GAS_PAYER_PRIVKEY,
-  DEFAULT_HMTOKEN_ADDR,
-  REPUTATION_ORACLE_PRIVKEY,
-  WORKER1_ADDR,
-  WORKER2_ADDR,
-} from '../test/utils/constants';
-import { manifest } from '../test/utils/manifest';
-import * as dotenv from 'dotenv';
-
-dotenv.config();
-
-const main = async () => {
-  // Create job object
-  const job = new Job({
-    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
-    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
-    manifest: manifest,
-    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
-    storageAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
-    storageSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    storageEndpoint: process.env.AWS_ENDPOINT,
-    storageBucket: process.env.AWS_BUCKET,
-    storagePublicBucket: process.env.AWS_PUBLIC_BUCKET,
-    logLevel: 'debug',
-  });
-
-  // Initialize new job
-  await job.initialize();
-
-  // Launch the job
-  await job.launch();
-
-  // Setup the job
-  await job.setup();
-
-  console.log(
-    `Status: ${await job.status()}, Balance: ${(
-      await job.balance()
-    )?.toString()}`
-  );
-
-  // Bulk payout workers
-  await job.bulkPayout(
-    [
-      {
-        address: WORKER1_ADDR,
-        amount: 70,
-      },
-      {
-        address: WORKER2_ADDR,
-        amount: 30,
-      },
-    ],
-    {
-      result: 'result',
-    }
-  );
-
-  // Complete the job
-  await job.complete();
-
-  console.log(
-    `Status: ${await job.status()}, Balance: ${(
-      await job.balance()
-    )?.toString()}`
-  );
-};
-
-main();