@rosen-bridge/abstract-extractor 0.3.0 → 1.0.0

package/tests/AbstractErgoExtractor.spec.ts

@@ -0,0 +1,281 @@
+import { V1 } from '@rosen-clients/ergo-explorer';
+import { describe, it, expect, vitest } from 'vitest';
+
+import {
+  OutputBox,
+  AbstractBoxData,
+  AbstractErgoExtractorAction,
+  CallbackType,
+  AbstractErgoExtractorEntity,
+} 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
+     * - 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: V1.OutputInfo | OutputBox) => {
+        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,
+      } as unknown as AbstractErgoExtractorAction<
+        AbstractBoxData,
+        AbstractErgoExtractorEntity
+      >;
+      const result = await extractor.processTransactions([tx], block);
+
+      expect(extractSpy).toBeCalledTimes(1);
+      expect(extractSpy).toBeCalledWith(tx.outputs[0]);
+      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,
+      } as unknown as AbstractErgoExtractorAction<
+        AbstractBoxData,
+        AbstractErgoExtractorEntity
+      >;
+      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: V1.OutputInfo | OutputBox) => {
+        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,
+      } as unknown as AbstractErgoExtractorAction<
+        AbstractBoxData,
+        AbstractErgoExtractorEntity
+      >;
+      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,
+      } as unknown as AbstractErgoExtractorAction<
+        AbstractBoxData,
+        AbstractErgoExtractorEntity
+      >;
+      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);
+    });
+  });
+});

package/tests/AbstractErgoExtractorAction.mock.ts

@@ -0,0 +1,45 @@
+import { DataSource } from 'typeorm';
+import { pick } from 'lodash-es';
+
+import {
+  AbstractErgoExtractorAction,
+  AbstractErgoExtractorEntity,
+  BlockInfo,
+  AbstractBoxData,
+} from '../lib';
+import { TestEntity } from './testUtils';
+
+export class TestErgoExtractorAction extends AbstractErgoExtractorAction<
+  AbstractBoxData,
+  AbstractErgoExtractorEntity
+> {
+  constructor(dataSource: DataSource) {
+    super(dataSource, TestEntity);
+  }
+
+  /**
+   * create the test database entity from data and block information
+   */
+  createEntity = (
+    boxes: AbstractBoxData[],
+    block: BlockInfo,
+    extractor: string
+  ): Omit<AbstractErgoExtractorEntity, 'id'>[] => {
+    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: AbstractErgoExtractorEntity[]
+  ): AbstractBoxData[] => {
+    return entities.map((data) => pick(data, ['boxId', 'serialized']));
+  };
+}

package/tests/AbstractErgoExtractorAction.spec.ts

@@ -0,0 +1,269 @@
+import { DataSource, Repository } from 'typeorm';
+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';
+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

@@ -3,11 +3,22 @@ import {
   AbstractInitializableErgoExtractor,
   AbstractInitializableErgoExtractorAction,
 } from '../../lib/ergo/initializable';
-import { OutputBox, ErgoExtractedData, BlockInfo } from '../../lib';
+import {
+  OutputBox,
+  AbstractBoxData,
+  BlockInfo,
+  AbstractErgoExtractorEntity,
+} from '../../lib';
 import { ergoBoxes } from './testData';
 
-export class MockedInitializableErgoExtractor extends AbstractInitializableErgoExtractor<ErgoExtractedData> {
-  actions: AbstractInitializableErgoExtractorAction<ErgoExtractedData>;
+export class MockedInitializableErgoExtractor extends AbstractInitializableErgoExtractor<
+  AbstractBoxData,
+  AbstractErgoExtractorEntity
+> {
+  actions: AbstractInitializableErgoExtractorAction<
+    AbstractBoxData,
+    AbstractErgoExtractorEntity
+  >;
 
   getId = () => 'Test';
 
@@ -21,11 +32,7 @@ export class MockedInitializableErgoExtractor extends AbstractInitializableErgoE
     return Promise.resolve({ boxes: ergoBoxes, hasNextBatch: true });
   };
 
-  extractBoxData = (
-    box: V1.OutputInfo | OutputBox,
-    blockId: string,
-    height: number
-  ) => {
+  extractBoxData = (box: V1.OutputInfo | OutputBox) => {
     return undefined;
   };
 }