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

package/dist/tests/AbstractErgoExtractor.spec.js

@@ -0,0 +1,241 @@
+import { describe, it, expect, vitest } from 'vitest';
+import { CallbackType, } from '../lib';
+import { block, extractedData, tx } from './testData';
+import { MockedErgoExtractor } from './AbstractErgoExtractor.mock';
+describe('AbstractErgoExtractor', () => {
+    describe('processTransactions', () => {
+        /**
+         * @target processTransactions should initialize extractor with specified id and insert status into db
+         * @dependencies
+         * @scenario
+         * - mock extractor
+         * - mock `hasData` to return true for one box
+         * - spy `extractBoxData` and `storeBoxes`
+         * - run test (call `processTransactions`)
+         * @expected
+         * - to call `extractBoxData` for the specific box and all input extensions
+         * - to insert the extracted box to database
+         * - to return true when total procedure is successful
+         * - to trigger `INSERT` callbacks with correct data
+         */
+        it('should process boxes with data and insert data into database', async () => {
+            const extractor = new MockedErgoExtractor();
+            const triggerCallbacks = vitest.fn();
+            extractor['triggerCallbacks'] = triggerCallbacks;
+            extractor.hasData = (box) => {
+                if (box.boxId == tx.outputs[0].boxId)
+                    return true;
+                return false;
+            };
+            const extractSpy = vitest.fn().mockReturnValue(extractedData);
+            extractor.extractBoxData = extractSpy;
+            const storeSpy = vitest.fn().mockResolvedValue(true);
+            const spendSpy = vitest.fn().mockResolvedValue([]);
+            extractor['actions'] = {
+                storeBoxes: storeSpy,
+                spendBoxes: spendSpy,
+            };
+            const result = await extractor.processTransactions([tx], block);
+            expect(extractSpy).toBeCalledTimes(1);
+            expect(extractSpy).toBeCalledWith(tx.outputs[0], [tx.inputs[0].extension, {}], {});
+            expect(storeSpy).toBeCalledWith([extractedData], block, 'Test');
+            expect(result).toEqual(true);
+            expect(triggerCallbacks).toBeCalledWith(CallbackType.Insert, [
+                extractedData,
+            ]);
+        });
+        /**
+         * @target processTransactions should extract spending information of all input boxes
+         * @dependencies
+         * @scenario
+         * - mock extractor (hasData returns false as default)
+         * - spy `extractBoxData`, `storeBoxes` and `spendBoxes`
+         * - run test (call `processTransactions`)
+         * @expected
+         * - not to call `extractBoxData` and `storeBoxes` when there is not any box with data
+         * - to extractor spend info of input boxes and call `spendBoxes`
+         * - to return true when total procedure is successful
+         * - to trigger `SPEND` callbacks with correct data
+         */
+        it('should extract spending information of all input boxes', async () => {
+            const extractor = new MockedErgoExtractor();
+            const triggerCallbacks = vitest.fn();
+            extractor['triggerCallbacks'] = triggerCallbacks;
+            const extractSpy = vitest.fn();
+            extractor.extractBoxData = extractSpy;
+            const storeSpy = vitest.fn().mockResolvedValue(true);
+            const spendSpy = vitest
+                .fn()
+                .mockResolvedValue([
+                { boxId: tx.inputs[0].boxId },
+                { boxId: tx.inputs[1].boxId },
+            ]);
+            extractor['actions'] = {
+                storeBoxes: storeSpy,
+                spendBoxes: spendSpy,
+            };
+            const result = await extractor.processTransactions([tx], block);
+            expect(extractSpy).not.toBeCalled();
+            expect(storeSpy).not.toBeCalled();
+            expect(spendSpy).toBeCalledWith([
+                { boxId: tx.inputs[0].boxId, txId: tx.id, index: 1 },
+                { boxId: tx.inputs[1].boxId, txId: tx.id, index: 2 },
+            ], block, 'Test');
+            expect(result).toEqual(true);
+            expect(triggerCallbacks).toBeCalledWith(CallbackType.Spend, [
+                { boxId: tx.inputs[0].boxId },
+                { boxId: tx.inputs[1].boxId },
+            ]);
+        });
+        /**
+         * @target processTransactions should return false if data insertion fails
+         * @dependencies
+         * @scenario
+         * - mock extractor
+         * - mock `hasData` to return true for one box
+         * - spy `extractBoxData` and `storeBoxes`
+         * - run test (call `processTransactions`)
+         * @expected
+         * - to return false when `insertBoxes` returns false
+         * - not to call `spendBoxes` if data insertion fails
+         */
+        it('should return false if data insertion fails', async () => {
+            const extractor = new MockedErgoExtractor();
+            extractor.hasData = (box) => {
+                if (box.boxId == tx.outputs[0].boxId)
+                    return true;
+                return false;
+            };
+            const extractSpy = vitest.fn().mockReturnValue(extractedData);
+            extractor.extractBoxData = extractSpy;
+            const storeSpy = vitest.fn().mockResolvedValue(false);
+            const spendSpy = vitest.fn();
+            extractor['actions'] = {
+                storeBoxes: storeSpy,
+                spendBoxes: spendSpy,
+            };
+            const result = await extractor.processTransactions([tx], block);
+            expect(result).toEqual(false);
+            expect(spendSpy).not.toBeCalled();
+        });
+    });
+    describe('forkBlock', () => {
+        /**
+         * @target forkBlock should remove all data extracted from the specified block
+         * @dependencies
+         * @scenario
+         * - mock extractor
+         * - spy `deleteBlockBoxes`
+         * - run test (call `forkBlock`)
+         * @expected
+         * - to call `deleteBlockBoxes` for the specific box
+         * - to trigger `DELETE` callbacks for the deleted box
+         * - to trigger `UPDATE` callbacks for the spent box
+         */
+        it('should remove all data extracted from the specified block', async () => {
+            const extractor = new MockedErgoExtractor();
+            const removeSpy = vitest.fn().mockResolvedValue({
+                deletedData: [{ boxId: 'box1' }],
+                updatedData: [{ boxId: 'box2' }],
+            });
+            extractor['actions'] = {
+                deleteBlockBoxes: removeSpy,
+            };
+            const triggerCallbackSpy = vitest.fn().mockClear();
+            extractor['triggerCallbacks'] = triggerCallbackSpy;
+            await extractor.forkBlock(block.hash);
+            expect(removeSpy).toBeCalledWith(block.hash, 'Test');
+            expect(triggerCallbackSpy).toBeCalledWith(CallbackType.Delete, [
+                { boxId: 'box1' },
+            ]);
+            expect(triggerCallbackSpy).toBeCalledWith(CallbackType.Update, [
+                { boxId: 'box2' },
+            ]);
+        });
+    });
+    describe('hook', () => {
+        /**
+         * @target hook should hook a new callback on insert with the new id
+         * @dependencies
+         * @scenario
+         * - mock extractor
+         * - mock a callback for insert
+         * - run test (call `hook`)
+         * @expected
+         * - hook the callback with the specified id
+         * - return true
+         */
+        it('should hook a new callback on insert with the new id', async () => {
+            const extractor = new MockedErgoExtractor();
+            const insertCallback = vitest.fn();
+            const id = await extractor.hook(CallbackType.Insert, insertCallback);
+            expect(extractor['callbacks'][CallbackType.Insert]).toEqual(new Map().set(id, insertCallback));
+        });
+    });
+    describe('unhook', () => {
+        /**
+         * @target unhook should unhook the callback on insert with the specified id
+         * @dependencies
+         * @scenario
+         * - mock extractor
+         * - mock a callback for insert
+         * - hook the callback
+         * - run test (call `unhook`)
+         * @expected
+         * - unhook the callback with the specified id
+         * - return true
+         */
+        it('should unhook the callback on insert with the specified id', async () => {
+            const extractor = new MockedErgoExtractor();
+            const insertCallback = vitest.fn();
+            const id = await extractor.hook(CallbackType.Insert, insertCallback);
+            const result = await extractor.unhook(CallbackType.Insert, id);
+            expect(result).toBeTruthy();
+            expect(extractor['callbacks'][CallbackType.Insert].get(id)).toEqual(undefined);
+        });
+        /**
+         * @target unhook should not unhook callbacks with the same id on other types
+         * @dependencies
+         * @scenario
+         * - mock extractor
+         * - mock two callbacks for insert
+         * - hook the first callback
+         * - run test (call `unhook` with the same id for second callback)
+         * @expected
+         * - not to change hooked callbacks when the callback with the id
+         * doesn't exists on the specified type
+         * - return false
+         */
+        it('should not unhook callbacks with the same id on other types', async () => {
+            const extractor = new MockedErgoExtractor();
+            const insertCallback = vitest.fn();
+            const id = await extractor.hook(CallbackType.Insert, insertCallback);
+            const result = await extractor.unhook(CallbackType.Update, id);
+            expect(result).toBeFalsy();
+            expect(extractor['callbacks'][CallbackType.Insert].get(id)).toEqual(insertCallback);
+            expect(extractor['callbacks'][CallbackType.Update].get(id)).toEqual(undefined);
+        });
+    });
+    describe('triggerCallbacks', () => {
+        /**
+         * @target triggerCallbacks should trigger all callbacks hooked on a type
+         * @dependencies
+         * @scenario
+         * - mock extractor
+         * - mock a callback for insert
+         * - hook the callback
+         * - run test (call `triggerCallbacks` for insert type)
+         * @expected
+         * - trigger all callbacks with the specified id
+         */
+        it('should trigger all callbacks hooked on a type', async () => {
+            const extractor = new MockedErgoExtractor();
+            const insertCallback = vitest.fn();
+            await extractor.hook(CallbackType.Insert, insertCallback);
+            const insertedData = [{ boxId: 'boxId', serialized: 'serialized' }];
+            await extractor['triggerCallbacks'](CallbackType.Insert, insertedData);
+            expect(insertCallback).toBeCalledWith(insertedData);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AbstractErgoExtractor.spec.js","sourceRoot":"","sources":["../../tests/AbstractErgoExtractor.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { V1 } from '@rosen-clients/ergo-explorer';\nimport { describe, it, expect, vitest } from 'vitest';\nimport { OutputBox } from '@rosen-bridge/scanner-interfaces';\n\nimport {\n  AbstractBoxData,\n  AbstractErgoExtractorAction,\n  CallbackType,\n  AbstractErgoExtractorEntity,\n} from '../lib';\nimport { block, extractedData, tx } from './testData';\nimport { MockedErgoExtractor } from './AbstractErgoExtractor.mock';\n\ndescribe('AbstractErgoExtractor', () => {\n  describe('processTransactions', () => {\n    /**\n     * @target processTransactions should initialize extractor with specified id and insert status into db\n     * @dependencies\n     * @scenario\n     * - mock extractor\n     * - mock `hasData` to return true for one box\n     * - spy `extractBoxData` and `storeBoxes`\n     * - run test (call `processTransactions`)\n     * @expected\n     * - to call `extractBoxData` for the specific box and all input extensions\n     * - to insert the extracted box to database\n     * - to return true when total procedure is successful\n     * - to trigger `INSERT` callbacks with correct data\n     */\n    it('should process boxes with data and insert data into database', async () => {\n      const extractor = new MockedErgoExtractor();\n      const triggerCallbacks = vitest.fn();\n      extractor['triggerCallbacks'] = triggerCallbacks;\n      extractor.hasData = (box: V1.OutputInfo | OutputBox) => {\n        if (box.boxId == tx.outputs[0].boxId) return true;\n        return false;\n      };\n      const extractSpy = vitest.fn().mockReturnValue(extractedData);\n      extractor.extractBoxData = extractSpy;\n      const storeSpy = vitest.fn().mockResolvedValue(true);\n      const spendSpy = vitest.fn().mockResolvedValue([]);\n      extractor['actions'] = {\n        storeBoxes: storeSpy,\n        spendBoxes: spendSpy,\n      } as unknown as AbstractErgoExtractorAction<\n        AbstractBoxData,\n        AbstractErgoExtractorEntity\n      >;\n      const result = await extractor.processTransactions([tx], block);\n\n      expect(extractSpy).toBeCalledTimes(1);\n      expect(extractSpy).toBeCalledWith(\n        tx.outputs[0],\n        [tx.inputs[0].extension, {}],\n        {}\n      );\n      expect(storeSpy).toBeCalledWith([extractedData], block, 'Test');\n      expect(result).toEqual(true);\n      expect(triggerCallbacks).toBeCalledWith(CallbackType.Insert, [\n        extractedData,\n      ]);\n    });\n\n    /**\n     * @target processTransactions should extract spending information of all input boxes\n     * @dependencies\n     * @scenario\n     * - mock extractor (hasData returns false as default)\n     * - spy `extractBoxData`, `storeBoxes` and `spendBoxes`\n     * - run test (call `processTransactions`)\n     * @expected\n     * - not to call `extractBoxData` and `storeBoxes` when there is not any box with data\n     * - to extractor spend info of input boxes and call `spendBoxes`\n     * - to return true when total procedure is successful\n     * - to trigger `SPEND` callbacks with correct data\n     */\n    it('should extract spending information of all input boxes', async () => {\n      const extractor = new MockedErgoExtractor();\n      const triggerCallbacks = vitest.fn();\n      extractor['triggerCallbacks'] = triggerCallbacks;\n      const extractSpy = vitest.fn();\n      extractor.extractBoxData = extractSpy;\n      const storeSpy = vitest.fn().mockResolvedValue(true);\n      const spendSpy = vitest\n        .fn()\n        .mockResolvedValue([\n          { boxId: tx.inputs[0].boxId },\n          { boxId: tx.inputs[1].boxId },\n        ]);\n      extractor['actions'] = {\n        storeBoxes: storeSpy,\n        spendBoxes: spendSpy,\n      } as unknown as AbstractErgoExtractorAction<\n        AbstractBoxData,\n        AbstractErgoExtractorEntity\n      >;\n      const result = await extractor.processTransactions([tx], block);\n\n      expect(extractSpy).not.toBeCalled();\n      expect(storeSpy).not.toBeCalled();\n      expect(spendSpy).toBeCalledWith(\n        [\n          { boxId: tx.inputs[0].boxId, txId: tx.id, index: 1 },\n          { boxId: tx.inputs[1].boxId, txId: tx.id, index: 2 },\n        ],\n        block,\n        'Test'\n      );\n      expect(result).toEqual(true);\n      expect(triggerCallbacks).toBeCalledWith(CallbackType.Spend, [\n        { boxId: tx.inputs[0].boxId },\n        { boxId: tx.inputs[1].boxId },\n      ]);\n    });\n\n    /**\n     * @target processTransactions should return false if data insertion fails\n     * @dependencies\n     * @scenario\n     * - mock extractor\n     * - mock `hasData` to return true for one box\n     * - spy `extractBoxData` and `storeBoxes`\n     * - run test (call `processTransactions`)\n     * @expected\n     * - to return false when `insertBoxes` returns false\n     * - not to call `spendBoxes` if data insertion fails\n     */\n    it('should return false if data insertion fails', async () => {\n      const extractor = new MockedErgoExtractor();\n      extractor.hasData = (box: V1.OutputInfo | OutputBox) => {\n        if (box.boxId == tx.outputs[0].boxId) return true;\n        return false;\n      };\n      const extractSpy = vitest.fn().mockReturnValue(extractedData);\n      extractor.extractBoxData = extractSpy;\n      const storeSpy = vitest.fn().mockResolvedValue(false);\n      const spendSpy = vitest.fn();\n      extractor['actions'] = {\n        storeBoxes: storeSpy,\n        spendBoxes: spendSpy,\n      } as unknown as AbstractErgoExtractorAction<\n        AbstractBoxData,\n        AbstractErgoExtractorEntity\n      >;\n      const result = await extractor.processTransactions([tx], block);\n\n      expect(result).toEqual(false);\n      expect(spendSpy).not.toBeCalled();\n    });\n  });\n\n  describe('forkBlock', () => {\n    /**\n     * @target forkBlock should remove all data extracted from the specified block\n     * @dependencies\n     * @scenario\n     * - mock extractor\n     * - spy `deleteBlockBoxes`\n     * - run test (call `forkBlock`)\n     * @expected\n     * - to call `deleteBlockBoxes` for the specific box\n     * - to trigger `DELETE` callbacks for the deleted box\n     * - to trigger `UPDATE` callbacks for the spent box\n     */\n    it('should remove all data extracted from the specified block', async () => {\n      const extractor = new MockedErgoExtractor();\n      const removeSpy = vitest.fn().mockResolvedValue({\n        deletedData: [{ boxId: 'box1' }],\n        updatedData: [{ boxId: 'box2' }],\n      });\n      extractor['actions'] = {\n        deleteBlockBoxes: removeSpy,\n      } as unknown as AbstractErgoExtractorAction<\n        AbstractBoxData,\n        AbstractErgoExtractorEntity\n      >;\n      const triggerCallbackSpy = vitest.fn().mockClear();\n      extractor['triggerCallbacks'] = triggerCallbackSpy;\n      await extractor.forkBlock(block.hash);\n      expect(removeSpy).toBeCalledWith(block.hash, 'Test');\n      expect(triggerCallbackSpy).toBeCalledWith(CallbackType.Delete, [\n        { boxId: 'box1' },\n      ]);\n      expect(triggerCallbackSpy).toBeCalledWith(CallbackType.Update, [\n        { boxId: 'box2' },\n      ]);\n    });\n  });\n\n  describe('hook', () => {\n    /**\n     * @target hook should hook a new callback on insert with the new id\n     * @dependencies\n     * @scenario\n     * - mock extractor\n     * - mock a callback for insert\n     * - run test (call `hook`)\n     * @expected\n     * - hook the callback with the specified id\n     * - return true\n     */\n    it('should hook a new callback on insert with the new id', async () => {\n      const extractor = new MockedErgoExtractor();\n      const insertCallback = vitest.fn();\n      const id = await extractor.hook(CallbackType.Insert, insertCallback);\n      expect(extractor['callbacks'][CallbackType.Insert]).toEqual(\n        new Map().set(id, insertCallback)\n      );\n    });\n  });\n\n  describe('unhook', () => {\n    /**\n     * @target unhook should unhook the callback on insert with the specified id\n     * @dependencies\n     * @scenario\n     * - mock extractor\n     * - mock a callback for insert\n     * - hook the callback\n     * - run test (call `unhook`)\n     * @expected\n     * - unhook the callback with the specified id\n     * - return true\n     */\n    it('should unhook the callback on insert with the specified id', async () => {\n      const extractor = new MockedErgoExtractor();\n      const insertCallback = vitest.fn();\n      const id = await extractor.hook(CallbackType.Insert, insertCallback);\n      const result = await extractor.unhook(CallbackType.Insert, id);\n      expect(result).toBeTruthy();\n      expect(extractor['callbacks'][CallbackType.Insert].get(id)).toEqual(\n        undefined\n      );\n    });\n\n    /**\n     * @target unhook should not unhook callbacks with the same id on other types\n     * @dependencies\n     * @scenario\n     * - mock extractor\n     * - mock two callbacks for insert\n     * - hook the first callback\n     * - run test (call `unhook` with the same id for second callback)\n     * @expected\n     * - not to change hooked callbacks when the callback with the id\n     * doesn't exists on the specified type\n     * - return false\n     */\n    it('should not unhook callbacks with the same id on other types', async () => {\n      const extractor = new MockedErgoExtractor();\n      const insertCallback = vitest.fn();\n      const id = await extractor.hook(CallbackType.Insert, insertCallback);\n      const result = await extractor.unhook(CallbackType.Update, id);\n      expect(result).toBeFalsy();\n      expect(extractor['callbacks'][CallbackType.Insert].get(id)).toEqual(\n        insertCallback\n      );\n      expect(extractor['callbacks'][CallbackType.Update].get(id)).toEqual(\n        undefined\n      );\n    });\n  });\n\n  describe('triggerCallbacks', () => {\n    /**\n     * @target triggerCallbacks should trigger all callbacks hooked on a type\n     * @dependencies\n     * @scenario\n     * - mock extractor\n     * - mock a callback for insert\n     * - hook the callback\n     * - run test (call `triggerCallbacks` for insert type)\n     * @expected\n     * - trigger all callbacks with the specified id\n     */\n    it('should trigger all callbacks hooked on a type', async () => {\n      const extractor = new MockedErgoExtractor();\n      const insertCallback = vitest.fn();\n      await extractor.hook(CallbackType.Insert, insertCallback);\n      const insertedData = [{ boxId: 'boxId', serialized: 'serialized' }];\n      await extractor['triggerCallbacks'](CallbackType.Insert, insertedData);\n      expect(insertCallback).toBeCalledWith(insertedData);\n    });\n  });\n});\n"]}

package/dist/tests/AbstractErgoExtractorAction.mock.d.ts

@@ -0,0 +1,15 @@
+import { DataSource } from '@rosen-bridge/extended-typeorm';
+import { BlockInfo } from '@rosen-bridge/scanner-interfaces';
+import { AbstractErgoExtractorAction, AbstractErgoExtractorEntity, AbstractBoxData } from '../lib';
+export declare class TestErgoExtractorAction extends AbstractErgoExtractorAction<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=AbstractErgoExtractorAction.mock.d.ts.map

package/dist/tests/AbstractErgoExtractorAction.mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractErgoExtractorAction.mock.d.ts","sourceRoot":"","sources":["../../tests/AbstractErgoExtractorAction.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,2BAA2B,EAC3B,eAAe,EAChB,MAAM,QAAQ,CAAC;AAGhB,qBAAa,uBAAwB,SAAQ,2BAA2B,CACtE,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/AbstractErgoExtractorAction.mock.js

@@ -0,0 +1,27 @@
+import { pick } from 'lodash-es';
+import { AbstractErgoExtractorAction, } from '../lib';
+import { TestEntity } from './testUtils';
+export class TestErgoExtractorAction extends AbstractErgoExtractorAction {
+    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/AbstractErgoExtractorAction.spec.d.ts

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

package/dist/tests/AbstractErgoExtractorAction.spec.d.ts.map

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

package/dist/tests/AbstractErgoExtractorAction.spec.js

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