@rosen-bridge/abstract-extractor 2.1.0 → 2.1.2

package/tests/AbstractErgoExtractorAction.spec.ts

@@ -1,268 +0,0 @@
-import { DataSource, Repository } from '@rosen-bridge/extended-typeorm';
-import { pick } from 'lodash-es';
-
-import { TestErgoExtractorAction } from './AbstractErgoExtractorAction.mock';
-import { createDatabase, TestEntity } from './testUtils';
-import { block, block2, sampleEntities } from './testData';
-import { SpendInfo } from '../lib';
-
-describe('AbstractErgoExtractorAction', () => {
-  let dataSource: DataSource;
-  let action: TestErgoExtractorAction;
-  let repository: Repository<TestEntity>;
-  beforeEach(async () => {
-    dataSource = await createDatabase();
-    action = new TestErgoExtractorAction(dataSource);
-    repository = dataSource.getRepository(TestEntity);
-  });
-
-  describe('storeBoxes', () => {
-    /**
-     * @target storeBoxes should save the passed box entities to database
-     * @dependencies
-     * @scenario
-     * - run test (call `storeBoxes` with 2 new boxes)
-     * @expected
-     * - to save 2 new entities
-     * - to return 2 inserted entity data
-     */
-    it(`should save the passed box entities to database`, async () => {
-      const result = await action.storeBoxes(
-        sampleEntities.slice(0, 2),
-        block,
-        'extractor1',
-      );
-
-      const [rows, rowsCount] = await repository.findAndCount();
-
-      expect(rowsCount).toEqual(2);
-      expect(rows[0]).toMatchObject({
-        ...sampleEntities[0],
-        extractor: 'extractor1',
-        block: block.hash,
-        height: block.height,
-        spendBlock: null,
-        spendHeight: null,
-      });
-      expect(rows[1]).toMatchObject({
-        ...sampleEntities[1],
-        extractor: 'extractor1',
-        block: block.hash,
-        height: block.height,
-        spendBlock: null,
-        spendHeight: null,
-      });
-      expect(result).toEqual(true);
-    });
-
-    /**
-     * @target storeBoxes should correctly save boxes with different extractors
-     * @dependencies
-     * @scenario
-     * - insert 2 boxes belonging to first-extractor
-     * - run test (call `storeBoxes` with same boxes for the second-extractor)
-     * @expected
-     * - to save 2 new entities belonging to second-extractor
-     * - to return 2 new inserted entity data
-     */
-    it(`should correctly save boxes with different extractors`, async () => {
-      await repository.insert([
-        {
-          ...sampleEntities[0],
-          extractor: 'first-extractor',
-          block: '1',
-          height: 1,
-        },
-        {
-          ...sampleEntities[1],
-          extractor: 'first-extractor',
-          block: '1',
-          height: 1,
-        },
-      ]);
-
-      const result = await action.storeBoxes(
-        [sampleEntities[0], sampleEntities[1]],
-        block,
-        'second-extractor',
-      );
-
-      const [insertedRows] = await repository.findAndCount();
-      expect(insertedRows[2]).toMatchObject({
-        ...sampleEntities[0],
-        extractor: 'second-extractor',
-        block: 'hash',
-        height: block.height,
-        spendBlock: null,
-        spendHeight: null,
-      });
-
-      expect(insertedRows[3]).toMatchObject({
-        ...sampleEntities[1],
-        extractor: 'second-extractor',
-        block: 'hash',
-        height: block.height,
-        spendBlock: null,
-        spendHeight: null,
-      });
-      expect(result).toEqual(true);
-    });
-
-    /**
-     * @target storeBoxes should update boxes correctly
-     * @dependencies
-     * @scenario
-     * - insert 2 boxes
-     * - run test (call `storeBoxes` with the same boxes and updated info)
-     * @expected
-     * - to update the existing box in database
-     * - to return updated box id
-     */
-    it(`storeBoxes should update boxes correctly`, async () => {
-      await repository.insert([
-        {
-          ...sampleEntities[0],
-          extractor: 'extractor',
-          block: '1',
-          height: 1,
-        },
-        {
-          ...sampleEntities[1],
-          extractor: 'extractor',
-          block: '1',
-          height: 1,
-        },
-      ]);
-
-      const result = await action.storeBoxes(
-        [
-          {
-            ...sampleEntities[0],
-            serialized: 'updatedBoxSerialized',
-          },
-        ],
-        block,
-        'extractor',
-      );
-      const [secondInsertRows, secondInsertRowsCount] =
-        await repository.findAndCount();
-      expect(secondInsertRowsCount).toEqual(2);
-      expect(secondInsertRows[0]).toMatchObject({
-        ...sampleEntities[0],
-        extractor: 'extractor',
-        serialized: 'updatedBoxSerialized',
-        block: block.hash,
-        height: block.height,
-        spendBlock: null,
-        spendHeight: null,
-      });
-      expect(result).toEqual(true);
-    });
-  });
-
-  describe('spendBoxes', () => {
-    /**
-     * @target spendBoxes should set spendBlock and spendHeight for a set of boxes
-     * @dependencies
-     * @scenario
-     * - insert two boxes
-     * - mock spending information for the first box
-     * - run test (call `spendBoxes`)
-     * @expected
-     * - spend the first box
-     * - return boxId and serialized of spent box
-     */
-    it(`should set spendBlock and spendHeight for a set of boxes`, async () => {
-      await action.storeBoxes(sampleEntities.slice(0, 2), block, 'extractor1');
-
-      const spendBlock = { ...block, hash: 'spendHash', height: 10006016 };
-      const spendInfos: Array<SpendInfo> = [
-        { txId: 'txId', boxId: sampleEntities[0].boxId, index: 0 },
-      ];
-
-      const spentBoxIds = await action.spendBoxes(
-        spendInfos,
-        spendBlock,
-        'extractor1',
-      );
-
-      const spentBoxes = await repository.findOneBy({
-        boxId: sampleEntities[0].boxId,
-        extractor: 'extractor1',
-      });
-
-      expect(spentBoxes).toMatchObject({
-        ...sampleEntities[0],
-        block: block.hash,
-        height: block.height,
-        extractor: 'extractor1',
-        spendBlock: spendBlock.hash,
-        spendHeight: spendBlock.height,
-      });
-      expect(spentBoxIds).toEqual([pick(sampleEntities[0], ['boxId'])]);
-    });
-  });
-
-  describe('deleteBlockBoxes', () => {
-    /**
-     * @target deleteBlockBoxes should delete the boxes created in the specified block
-     * @dependencies
-     * @scenario
-     * - insert four boxes created in two different blocks
-     * - run test(call `deleteBlockBoxes` to delete block2)
-     * @expected
-     * - to delete the two boxes created in block2
-     * - to return the deleted entity data
-     */
-    it(`should delete the boxes created in the specified block`, async () => {
-      await action.storeBoxes(sampleEntities.slice(0, 2), block, 'extractor1');
-      await action.storeBoxes(sampleEntities.slice(2), block2, 'extractor1');
-
-      const result = await action.deleteBlockBoxes(block2.hash, 'extractor1');
-
-      const [rows, rowsCount] = await repository.findAndCount();
-
-      expect(rowsCount).toEqual(2);
-      expect(rows.map((row) => row.boxId)).not.toContain(
-        sampleEntities.slice(2).map((box) => box.boxId),
-      );
-      expect(result).toEqual({
-        deletedData: action.convertEntityToData(
-          sampleEntities.slice(2) as TestEntity[],
-        ),
-        updatedData: [],
-      });
-    });
-
-    /**
-     * @target deleteBlockBoxes should update the boxes spent in the specified block
-     * @dependencies
-     * @scenario
-     * - insert four boxes created in a block
-     * - spend one of the in the block2
-     * - run test(call `deleteBlockBoxes` to delete block2)
-     * @expected
-     * - to update the box spent in block2
-     * - to return the updated entity boxId and serialized
-     */
-    it(`should update the boxes spent in the specified block`, async () => {
-      await action.storeBoxes(sampleEntities, block, 'extractor1');
-      const spendInfos: Array<SpendInfo> = [
-        { txId: 'txId', boxId: sampleEntities[0].boxId, index: 0 },
-      ];
-      await action.spendBoxes(spendInfos, block2, 'extractor1');
-      const result = await action.deleteBlockBoxes(block2.hash, 'extractor1');
-
-      const [rows, rowsCount] = await repository.findAndCount();
-
-      expect(rowsCount).toEqual(4);
-      expect(rows.map((row) => row.boxId)).not.toContain(
-        sampleEntities.slice(2).map((box) => box.boxId),
-      );
-      expect(result).toEqual({
-        deletedData: [],
-        updatedData: [pick(sampleEntities[0], ['boxId'])],
-      });
-    });
-  });
-});

package/tests/initializable/AbstractInitializable.mock.ts

@@ -1,44 +0,0 @@
-import { V1 } from '@rosen-clients/ergo-explorer';
-import { BlockInfo, OutputBox } from '@rosen-bridge/scanner-interfaces';
-
-import {
-  AbstractInitializableErgoExtractor,
-  AbstractInitializableErgoExtractorAction,
-} from '../../lib/ergo/initializable';
-import { AbstractBoxData, AbstractErgoExtractorEntity } from '../../lib';
-import { ergoBoxes } from './testData';
-
-export class MockedInitializableErgoExtractor extends AbstractInitializableErgoExtractor<
-  AbstractBoxData,
-  AbstractErgoExtractorEntity
-> {
-  actions: AbstractInitializableErgoExtractorAction<
-    AbstractBoxData,
-    AbstractErgoExtractorEntity
-  >;
-
-  getId = () => 'Test';
-
-  hasData = (
-    box: V1.OutputInfo | OutputBox, // eslint-disable-line @typescript-eslint/no-unused-vars
-  ) => false;
-
-  getTxBlock = async (
-    txId: string, // eslint-disable-line @typescript-eslint/no-unused-vars
-  ): Promise<BlockInfo> => {
-    return { hash: 'hash', height: 100 };
-  };
-
-  getBoxesWithOffsetLimit = (
-    offset: number, // eslint-disable-line @typescript-eslint/no-unused-vars
-    limit: number, // eslint-disable-line @typescript-eslint/no-unused-vars
-  ) => {
-    return Promise.resolve({ boxes: ergoBoxes, hasNextBatch: true });
-  };
-
-  extractBoxData = (
-    box: V1.OutputInfo | OutputBox, // eslint-disable-line @typescript-eslint/no-unused-vars
-  ) => {
-    return undefined;
-  };
-}

package/tests/initializable/AbstractInitializable.spec.ts

@@ -1,386 +0,0 @@
-import { ErgoNetworkType } from '@rosen-bridge/scanner-interfaces';
-
-import {
-  NodeNetwork,
-  AbstractBoxData,
-  ExplorerNetwork,
-  AbstractErgoExtractorEntity,
-} from '../../lib';
-import { MockedInitializableErgoExtractor } from './AbstractInitializable.mock';
-import { transactionBatch } from './testData';
-import { RETRIAL_COUNT } from '../../lib/constants';
-import { AbstractInitializableErgoExtractorAction } from '../../lib/ergo/initializable';
-
-describe('AbstractInitializableErgoExtractor', () => {
-  describe('getTotalTxCount', () => {
-    /**
-     * @target getTotalTxCount should return the total tx count
-     * @dependencies
-     * - explorer network
-     * @scenario
-     * - mock extractor
-     * - mock `getAddressTransactionsWithOffsetLimit` in node network
-     * - run test (call `getTotalTxCount`)
-     * @expected
-     * - return one total tx count
-     */
-    it('should return the total tx count', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-      );
-      (
-        extractor['network'] as NodeNetwork
-      ).getAddressTransactionsWithOffsetLimit = vitest.fn().mockResolvedValue({
-        items: [],
-        total: 196704,
-      });
-      const totalTxCount = await extractor['getTotalTxCount']();
-      expect(totalTxCount).toEqual(196704);
-    });
-  });
-
-  describe('processTransactionBatch', () => {
-    /**
-     * @target processTransactionBatch should group transactions and process them in correct order
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - spy `processTransactions`
-     * - run test (call `processTransactionBatch`)
-     * @expected
-     * - to group txs in two blocks
-     * - to process each blocks transaction separately
-     */
-    it('should group transactions and process them in correct order', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-      );
-      const processSpy = vitest.fn().mockResolvedValue(true);
-      extractor.processTransactions = processSpy;
-      await extractor['processTransactionBatch'](transactionBatch);
-      expect(processSpy).toBeCalledTimes(2);
-      expect(processSpy).toHaveBeenCalledWith([transactionBatch[2]], {
-        hash: '92eaff11a4a1c29b8654473258f9d837e9ce99fc0a8a4f27c484d5871afcde64',
-        height: 1320698,
-      });
-      expect(processSpy).toHaveBeenLastCalledWith(
-        transactionBatch.slice(0, 2),
-        {
-          hash: 'b861e2134821fcf1fcdad7e6edd56c4e4495b42b2fd72762a4c79ed1db78b44b',
-          height: 1320705,
-        },
-      );
-    });
-
-    /**
-     * @target processTransactionBatch should throw error when processing transactions fails for a block
-     * @dependencies
-     * @scenario
-     * - mock extractor
-     * - spy `processTransactions` to return false (always fails)
-     * - run test (call `processTransactionBatch`)
-     * @expected
-     * - to throw error
-     */
-    it('should throw error when processing transactions fails for a block', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-      );
-      extractor.processTransactions = vitest.fn().mockResolvedValue(false);
-      await expect(() =>
-        extractor['processTransactionBatch'](transactionBatch),
-      ).rejects.toThrowError();
-    });
-  });
-
-  describe('initWithRetrial', () => {
-    /**
-     * @target initWithRetrial should not run the init job when its not set
-     * @dependencies
-     * - database
-     * @scenario
-     * - mock extractor with false initialization
-     * - mock `removeAllData` in database actions
-     * - mock init job
-     * - run test (call `initWithRetrial`)
-     * @expected
-     * - not to remove database old data
-     * - not to run the init job
-     */
-    it('should not run the init job when its not set', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-        undefined,
-        false,
-      );
-      const removeSpy = vitest.fn();
-      extractor['actions'] = {
-        removeAllData: removeSpy,
-      } as unknown as AbstractInitializableErgoExtractorAction<
-        AbstractBoxData,
-        AbstractErgoExtractorEntity
-      >;
-      const initSpy = vitest.fn();
-      await extractor['initWithRetrial'](initSpy);
-      expect(removeSpy).not.toHaveBeenCalled();
-      expect(initSpy).not.toHaveBeenCalled();
-    });
-
-    /**
-     * @target initWithRetrial should call init job once
-     * @dependencies
-     * - database
-     * @scenario
-     * - mock extractor
-     * - mock `removeAllData` in database actions
-     * - mock init job
-     * - run test (call `initWithRetrial`)
-     * @expected
-     * - to remove database old data once
-     * - call init job once
-     */
-    it('should call init job once', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-      );
-      const removeSpy = vitest.fn();
-      extractor['actions'] = {
-        removeAllData: removeSpy,
-      } as unknown as AbstractInitializableErgoExtractorAction<
-        AbstractBoxData,
-        AbstractErgoExtractorEntity
-      >;
-      const initSpy = vitest.fn();
-      await extractor['initWithRetrial'](initSpy);
-      expect(removeSpy).toHaveBeenCalledOnce();
-      expect(initSpy).toHaveBeenCalledOnce();
-    });
-
-    /**
-     * @target initWithRetrial should call init job RETRIAL_COUNT number of times
-     * @dependencies
-     * - database
-     * @scenario
-     * - mock extractor
-     * - mock `removeAllData` in database actions
-     * - mock init job to throw error
-     * - run test (call `initWithRetrial`)
-     * @expected
-     * - to remove database old data once
-     * - call init job RETRIAL_COUNT number of times
-     * - to throw error after trials
-     */
-    it('should call init job RETRIAL_COUNT number of times', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-      );
-      const removeSpy = vitest.fn();
-      extractor['actions'] = {
-        removeAllData: removeSpy,
-      } as unknown as AbstractInitializableErgoExtractorAction<
-        AbstractBoxData,
-        AbstractErgoExtractorEntity
-      >;
-      const initSpy = vitest.fn().mockRejectedValue(0);
-      await expect(
-        async () => await extractor['initWithRetrial'](initSpy),
-      ).rejects.toThrowError();
-      expect(removeSpy).toHaveBeenCalledOnce();
-      expect(initSpy).toHaveBeenCalledTimes(RETRIAL_COUNT);
-    });
-  });
-
-  describe('initializeWithNode', () => {
-    /**
-     * @target initializeWithNode should process all transactions bellow the init height twice
-     * @dependencies
-     * - node network
-     * @scenario
-     * - mock extractor
-     * - mock `getAddressTransactionsWithOffsetLimit` in node network
-     * - mock `initWithRetrial` to run the job once
-     * - mock `getTotalTxCount` to return 3
-     * - run test (call `initializeWithNode`)
-     * @expected
-     * - to filter the transactions and process the txs bellow the init height
-     * - to process all filtered transactions twice
-     */
-    it('should process all transactions bellow the init height twice', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-      );
-      (
-        extractor['network'] as NodeNetwork
-      ).getAddressTransactionsWithOffsetLimit = vitest.fn().mockResolvedValue({
-        items: transactionBatch,
-        total: 3,
-      });
-      extractor['initWithRetrial'] = async (job: () => Promise<void>) => job();
-      extractor['getTotalTxCount'] = async () => 3;
-      const processSpy = vitest.fn();
-      extractor['processTransactionBatch'] = processSpy;
-      await extractor['initializeWithNode']({ hash: 'hash', height: 1320698 });
-      expect(processSpy).toBeCalledTimes(2);
-      expect(processSpy).toBeCalledWith([transactionBatch[2]]);
-    });
-
-    /**
-     * @target initializeWithNode should throw error when total transaction count changes
-     * @dependencies
-     * - node network
-     * @scenario
-     * - mock extractor
-     * - mock `getAddressTransactionsWithOffsetLimit` in node network
-     * - mock `initWithRetrial` to run the job once
-     * - mock `getTotalTxCount` to return 3 then 4
-     * - run test (call `initializeWithNode`)
-     * @expected
-     * - to throw error when the number of transactions change during initialization
-     */
-    it('should throw error when total transaction count changes', async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Node,
-        'node_url',
-        'address',
-      );
-      (
-        extractor['network'] as NodeNetwork
-      ).getAddressTransactionsWithOffsetLimit = vitest.fn().mockResolvedValue({
-        items: transactionBatch,
-        total: 3,
-      });
-      extractor['initWithRetrial'] = async (job: () => Promise<void>) => job();
-      extractor['getTotalTxCount'] = vitest
-        .fn()
-        .mockResolvedValueOnce(3)
-        .mockResolvedValue(4);
-      extractor['processTransactionBatch'] = vitest.fn();
-      expect(() =>
-        extractor['initializeWithNode']({ hash: 'hash', height: 1320698 }),
-      ).rejects.toThrowError();
-    });
-  });
-
-  describe('initializeWithExplorer', () => {
-    /**
-     * @target initializeWithExplorer should limit the height and process
-     * transactions when they are less than the API_LIMIT
-     * @dependencies
-     * - explorer network
-     * @scenario
-     * - mock extractor
-     * - mock `initWithRetrial` to run the job once
-     * - mock `getAddressTransactionsWithHeight` in explorer network
-     *    return API_LIMIT transactions in first call (to limit the height range)
-     *    return 0 transactions in second call (to pass a range without process)
-     *    return transactionBatch in last call (to process the transactions when they are less than API_LIMIT)
-     * - run test (call `initializeWithExplorer`)
-     * @expected
-     * - to limit the height when the transaction count is equal to API_LIMIT
-     * - to cover all height ranges
-     * - to process transactions when they are less than API_LIMIT
-     */
-    it(`should limit the height and process transactions when they are less than
-      the API_LIMIT`, async () => {
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Explorer,
-        'explorer_url',
-        'address',
-      );
-      extractor['initWithRetrial'] = async (job: () => Promise<void>) => job();
-      const addressTxSpy = vitest
-        .fn()
-        .mockResolvedValueOnce(new Array(100).fill(transactionBatch[0]))
-        .mockResolvedValueOnce([])
-        .mockResolvedValueOnce(transactionBatch);
-      (
-        extractor['network'] as ExplorerNetwork
-      ).getAddressTransactionsWithHeight = addressTxSpy;
-      const processSpy = vitest.fn();
-      extractor['processTransactionBatch'] = processSpy;
-      await extractor['initializeWithExplorer']({
-        hash: 'hash',
-        height: 1320800,
-      });
-      expect(addressTxSpy).toHaveBeenCalledWith('address', 0, 1320800);
-      expect(addressTxSpy).toHaveBeenCalledWith('address', 0, 660400);
-      expect(addressTxSpy).toHaveBeenLastCalledWith('address', 660401, 1320800);
-      expect(processSpy).toHaveBeenCalledTimes(1);
-      expect(processSpy).toHaveBeenCalledWith(transactionBatch);
-    });
-
-    /**
-     * @target initializeWithExplorer should process all block transactions when
-     * the number of transactions in the block is more than API_LIMIT
-     * @dependencies
-     * - explorer network
-     * @scenario
-     * - mock extractor
-     * - mock `initWithRetrial` to run the job once
-     * - mock `getAddressTransactionsWithHeight` to return 100 transactions in one block
-     * - spy all other functions to check the calls
-     * - run test (call `initializeWithExplorer`)
-     * @expected
-     * - to process all transactions in block 1320000
-     * - not to stuck at a large block and complete the process
-     */
-    it(`should process all block transactions when the number of transactions in
-      the block is more than API_LIMIT`, async () => {
-      // mock extractor
-      const extractor = new MockedInitializableErgoExtractor(
-        ErgoNetworkType.Explorer,
-        'explorer_url',
-        'address',
-      );
-      // mock `initWithRetrial` to run the job once
-      extractor['initWithRetrial'] = async (job: () => Promise<void>) => job();
-      // mock `getAddressTransactionsWithHeight` to return 100 transactions in one block
-      const exNetwork = extractor['network'] as ExplorerNetwork;
-      const addressTxSpy = vitest
-        .fn()
-        .mockImplementation(
-          (address: string, fromHeight: number, toHeight: number) => {
-            if (fromHeight <= 1320000 && toHeight >= 1320000)
-              return new Array(100).fill(transactionBatch[0]);
-            return [];
-          },
-        );
-      exNetwork.getAddressTransactionsWithHeight = addressTxSpy;
-      // spy all other functions to check the calls
-      const blockIdSpy = vi.fn().mockResolvedValue('blockId');
-      const blockTxsSpy = vi.fn().mockResolvedValue([]);
-      exNetwork.getBlockIdAtHeight = blockIdSpy;
-      exNetwork.getBlockTxs = blockTxsSpy;
-      const processSpy = vitest.fn();
-      const processBatchSpy = vitest.fn();
-      extractor.processTransactions = processSpy;
-      extractor['processTransactionBatch'] = processBatchSpy;
-      // run test (call `initializeWithExplorer`)
-      await extractor['initializeWithExplorer']({
-        hash: 'hash',
-        height: 1320800,
-      });
-      expect(blockIdSpy).toHaveBeenCalledWith(1320000);
-      expect(blockTxsSpy).toHaveBeenCalledWith('blockId');
-      expect(processSpy).toHaveBeenCalledWith([], {
-        hash: 'blockId',
-        height: 1320000,
-      });
-      expect(processBatchSpy).not.toBeCalled();
-    });
-  });
-});