@rosen-bridge/abstract-extractor 2.0.1 → 2.0.3-52fc0239

package/dist/tests/initializable/AbstractInitializable.mock.d.ts

@@ -0,0 +1,60 @@
+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';
+export declare class MockedInitializableErgoExtractor extends AbstractInitializableErgoExtractor<AbstractBoxData, AbstractErgoExtractorEntity> {
+    actions: AbstractInitializableErgoExtractorAction<AbstractBoxData, AbstractErgoExtractorEntity>;
+    getId: () => string;
+    hasData: (box: V1.OutputInfo | OutputBox) => boolean;
+    getTxBlock: (txId: string) => Promise<BlockInfo>;
+    getBoxesWithOffsetLimit: (offset: number, limit: number) => Promise<{
+        boxes: ({
+            boxId: string;
+            transactionId: string;
+            blockId: string;
+            value: bigint;
+            index: number;
+            creationHeight: number;
+            inclusionHeight: number;
+            ergoTree: string;
+            address: string;
+            assets: {
+                tokenId: string;
+                index: number;
+                amount: bigint;
+                name: string;
+                decimals: number;
+            }[];
+            additionalRegisters: {};
+            spentHeight?: undefined;
+            spentBlockId?: undefined;
+            spentTransactionId?: undefined;
+            spentIndex?: undefined;
+        } | {
+            boxId: string;
+            transactionId: string;
+            blockId: string;
+            value: bigint;
+            index: number;
+            creationHeight: number;
+            inclusionHeight: number;
+            ergoTree: string;
+            address: string;
+            assets: {
+                tokenId: string;
+                index: number;
+                amount: bigint;
+                name: string;
+                decimals: number;
+            }[];
+            additionalRegisters: {};
+            spentHeight: number;
+            spentBlockId: string;
+            spentTransactionId: string;
+            spentIndex: number;
+        })[];
+        hasNextBatch: boolean;
+    }>;
+    extractBoxData: (box: V1.OutputInfo | OutputBox) => undefined;
+}
+//# sourceMappingURL=AbstractInitializable.mock.d.ts.map

package/dist/tests/initializable/AbstractInitializable.mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractInitializable.mock.d.ts","sourceRoot":"","sources":["../../../tests/initializable/AbstractInitializable.mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,8BAA8B,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EACL,kCAAkC,EAClC,wCAAwC,EACzC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AAGzE,qBAAa,gCAAiC,SAAQ,kCAAkC,CACtF,eAAe,EACf,2BAA2B,CAC5B;IACC,OAAO,EAAE,wCAAwC,CAC/C,eAAe,EACf,2BAA2B,CAC5B,CAAC;IAEF,KAAK,eAAgB;IAErB,OAAO,QACA,GAAG,UAAU,GAAG,SAAS,aACrB;IAEX,UAAU,SACF,MAAM,KACX,QAAQ,SAAS,CAAC,CAEnB;IAEF,uBAAuB,WACb,MAAM,SACP,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAGb;IAEF,cAAc,QACP,GAAG,UAAU,GAAG,SAAS,eAG9B;CACH"}

package/dist/tests/initializable/AbstractInitializable.mock.js

@@ -0,0 +1,22 @@
+import { AbstractInitializableErgoExtractor, } from '../../lib/ergo/initializable';
+import { ergoBoxes } from './testData';
+export class MockedInitializableErgoExtractor extends AbstractInitializableErgoExtractor {
+    actions;
+    getId = () => 'Test';
+    hasData = (box // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) => false;
+    getTxBlock = async (txId // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) => {
+        return { hash: 'hash', height: 100 };
+    };
+    getBoxesWithOffsetLimit = (offset, // eslint-disable-line @typescript-eslint/no-unused-vars
+    limit // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) => {
+        return Promise.resolve({ boxes: ergoBoxes, hasNextBatch: true });
+    };
+    extractBoxData = (box // eslint-disable-line @typescript-eslint/no-unused-vars
+    ) => {
+        return undefined;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tests/initializable/AbstractInitializable.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AbstractInitializable.spec.d.ts.map

package/dist/tests/initializable/AbstractInitializable.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractInitializable.spec.d.ts","sourceRoot":"","sources":["../../../tests/initializable/AbstractInitializable.spec.ts"],"names":[],"mappings":""}

package/dist/tests/initializable/AbstractInitializable.spec.js

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

package/dist/tests/initializable/AbstractInitializableAction.mock.d.ts

@@ -0,0 +1,15 @@
+import { DataSource } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoExtractorEntity, AbstractBoxData, AbstractInitializableErgoExtractorAction } from '../../lib';
+export declare class TestInitializableErgoExtractorAction extends AbstractInitializableErgoExtractorAction<AbstractBoxData, AbstractErgoExtractorEntity> {
+    constructor(dataSource: DataSource);
+    /**
+     * create the test database entity from data and block information
+     */
+    createEntity: (boxes: AbstractBoxData[], block: BlockInfo, extractor: string) => Omit<AbstractErgoExtractorEntity, 'id'>[];
+    /**
+     * convert the database entity back to raw data
+     */
+    convertEntityToData: (entities: AbstractErgoExtractorEntity[]) => AbstractBoxData[];
+}
+//# sourceMappingURL=AbstractInitializableAction.mock.d.ts.map

package/dist/tests/initializable/AbstractInitializableAction.mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractInitializableAction.mock.d.ts","sourceRoot":"","sources":["../../../tests/initializable/AbstractInitializableAction.mock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAE5D,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAE7D,OAAO,EACL,2BAA2B,EAC3B,eAAe,EACf,wCAAwC,EACzC,MAAM,WAAW,CAAC;AAGnB,qBAAa,oCAAqC,SAAQ,wCAAwC,CAChG,eAAe,EACf,2BAA2B,CAC5B;gBACa,UAAU,EAAE,UAAU;IAIlC;;OAEG;IACH,YAAY,UACH,eAAe,EAAE,SACjB,SAAS,aACL,MAAM,KAChB,KAAK,2BAA2B,EAAE,IAAI,CAAC,EAAE,CAQ1C;IAEF;;OAEG;IACH,mBAAmB,aACP,2BAA2B,EAAE,KACtC,eAAe,EAAE,CAElB;CACH"}

package/dist/tests/initializable/AbstractInitializableAction.mock.js

@@ -0,0 +1,27 @@
+import { pick } from 'lodash-es';
+import { AbstractInitializableErgoExtractorAction, } from '../../lib';
+import { TestEntity } from '../testUtils';
+export class TestInitializableErgoExtractorAction extends AbstractInitializableErgoExtractorAction {
+    constructor(dataSource) {
+        super(dataSource, TestEntity);
+    }
+    /**
+     * create the test database entity from data and block information
+     */
+    createEntity = (boxes, block, extractor) => {
+        return boxes.map((box) => ({
+            boxId: box.boxId,
+            block: block.hash,
+            height: block.height,
+            serialized: box.serialized,
+            extractor: extractor,
+        }));
+    };
+    /**
+     * convert the database entity back to raw data
+     */
+    convertEntityToData = (entities) => {
+        return entities.map((data) => pick(data, ['boxId', 'serialized']));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tests/initializable/AbstractInitializableAction.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AbstractInitializableAction.spec.d.ts.map

package/dist/tests/initializable/AbstractInitializableAction.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractInitializableAction.spec.d.ts","sourceRoot":"","sources":["../../../tests/initializable/AbstractInitializableAction.spec.ts"],"names":[],"mappings":""}

package/dist/tests/initializable/AbstractInitializableAction.spec.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestInitializableErgoExtractorAction } from './AbstractInitializableAction.mock';
+import { createDatabase, TestEntity } from '../testUtils';
+import { sampleEntities } from '../testData';
+describe('AbstractErgoExtractorAction', () => {
+    let dataSource;
+    let action;
+    let repository;
+    beforeEach(async () => {
+        dataSource = await createDatabase();
+        action = new TestInitializableErgoExtractorAction(dataSource);
+        repository = dataSource.getRepository(TestEntity);
+    });
+    describe('removeAllData', () => {
+        /**
+         * @target removeAllData should remove all available data related to this extractor
+         * @dependencies
+         * @scenario
+         * - insert 4 entities related to this extractor
+         * - run test (call `removeAllData`)
+         * @expected
+         * - to have 4 entities before removing
+         * - to have no remaining entities after remove
+         */
+        it(`should remove all available data related to this extractor`, async () => {
+            await dataSource.getRepository(TestEntity).insert(sampleEntities);
+            const countBefore = await repository.count();
+            await action.removeAllData('extractor');
+            const countAfter = await repository.count();
+            expect(countBefore).toEqual(4);
+            expect(countAfter).toEqual(0);
+        });
+        /**
+         * @target removeAllData should not remove any data related to another extractor
+         * @dependencies
+         * @scenario
+         * - insert 4 entities related to another extractor
+         * - run test (call `removeAllData`)
+         * @expected
+         * - to have 4 entities after removing
+         */
+        it(`should not remove any data related to another extractor`, async () => {
+            await dataSource.getRepository(TestEntity).insert(sampleEntities.map((entity) => ({
+                ...entity,
+                extractor: 'extractor-new',
+            })));
+            const countBefore = await repository.count();
+            await action.removeAllData('extractor');
+            const countAfter = await repository.count();
+            expect(countBefore).toEqual(4);
+            expect(countAfter).toEqual(4);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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