@rosen-bridge/abstract-extractor 0.3.1 → 1.0.0

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';
 

package/tests/initializable/AbstractInitializable.spec.ts

@@ -3,8 +3,9 @@ import { describe, expect, it, vi, vitest } from 'vitest';
 import {
   ErgoNetworkType,
   NodeNetwork,
-  ErgoExtractedData,
+  AbstractBoxData,
   ExplorerNetwork,
+  AbstractErgoExtractorEntity,
 } from '../../lib';
 import { MockedInitializableErgoExtractor } from './AbstractInitializable.mock';
 import { transactionBatch } from './testData';
@@ -59,7 +60,7 @@ describe('AbstractInitializableErgoExtractor', () => {
         'node_url',
         'address'
       );
-      const processSpy = vitest.fn();
+      const processSpy = vitest.fn().mockResolvedValue(true);
       extractor.processTransactions = processSpy;
       await extractor['processTransactionBatch'](transactionBatch);
       expect(processSpy).toBeCalledTimes(2);
@@ -75,6 +76,28 @@ describe('AbstractInitializableErgoExtractor', () => {
         }
       );
     });
+
+    /**
+     * @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', () => {
@@ -102,7 +125,10 @@ describe('AbstractInitializableErgoExtractor', () => {
       const removeSpy = vitest.fn();
       extractor['actions'] = {
         removeAllData: removeSpy,
-      } as unknown as AbstractInitializableErgoExtractorAction<ErgoExtractedData>;
+      } as unknown as AbstractInitializableErgoExtractorAction<
+        AbstractBoxData,
+        AbstractErgoExtractorEntity
+      >;
       const initSpy = vitest.fn();
       await extractor['initWithRetrial'](initSpy);
       expect(removeSpy).not.toHaveBeenCalled();
@@ -131,7 +157,10 @@ describe('AbstractInitializableErgoExtractor', () => {
       const removeSpy = vitest.fn();
       extractor['actions'] = {
         removeAllData: removeSpy,
-      } as unknown as AbstractInitializableErgoExtractorAction<ErgoExtractedData>;
+      } as unknown as AbstractInitializableErgoExtractorAction<
+        AbstractBoxData,
+        AbstractErgoExtractorEntity
+      >;
       const initSpy = vitest.fn();
       await extractor['initWithRetrial'](initSpy);
       expect(removeSpy).toHaveBeenCalledOnce();
@@ -161,7 +190,10 @@ describe('AbstractInitializableErgoExtractor', () => {
       const removeSpy = vitest.fn();
       extractor['actions'] = {
         removeAllData: removeSpy,
-      } as unknown as AbstractInitializableErgoExtractorAction<ErgoExtractedData>;
+      } as unknown as AbstractInitializableErgoExtractorAction<
+        AbstractBoxData,
+        AbstractErgoExtractorEntity
+      >;
       const initSpy = vitest.fn().mockRejectedValue(0);
       await expect(
         async () => await extractor['initWithRetrial'](initSpy)

package/tests/initializable/AbstractInitializableAction.mock.ts

@@ -0,0 +1,45 @@
+import { DataSource } from 'typeorm';
+import { pick } from 'lodash-es';
+
+import {
+  AbstractErgoExtractorEntity,
+  BlockInfo,
+  AbstractBoxData,
+  AbstractInitializableErgoExtractorAction,
+} from '../../lib';
+import { TestEntity } from '../testUtils';
+
+export class TestInitializableErgoExtractorAction extends AbstractInitializableErgoExtractorAction<
+  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/initializable/AbstractInitializableAction.spec.ts

@@ -0,0 +1,65 @@
+import { DataSource, Repository } from 'typeorm';
+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: DataSource;
+  let action: TestInitializableErgoExtractorAction;
+  let repository: Repository<TestEntity>;
+  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);
+    });
+  });
+});

package/tests/testData.ts

@@ -1,4 +1,5 @@
 import { Block } from '../lib';
+import { TestEntity } from './testUtils';
 
 export const tx = {
   id: '3b91fbd2b6f4f3f971098655ffa320841001b071908de057cdf8c425cd3b3e61',
@@ -107,3 +108,40 @@ export const block: Block = {
   height: 100,
   parentHash: 'parentHash',
 } as Block;
+
+export const block2: Block = {
+  hash: 'hash2',
+  height: 101,
+  parentHash: 'parentHash2',
+} as Block;
+
+export const sampleEntities: Omit<TestEntity, 'id'>[] = [
+  {
+    extractor: 'extractor',
+    boxId: '1',
+    serialized: 'serialized1',
+    block: 'blockId1',
+    height: 100,
+  },
+  {
+    extractor: 'extractor',
+    boxId: '2',
+    serialized: 'serialized2',
+    block: 'blockId2',
+    height: 200,
+  },
+  {
+    extractor: 'extractor',
+    boxId: '3',
+    serialized: 'serialized3',
+    block: 'blockId3',
+    height: 300,
+  },
+  {
+    extractor: 'extractor',
+    boxId: '4',
+    serialized: 'serialized4',
+    block: 'blockId4',
+    height: 400,
+  },
+];

package/tests/testUtils.ts

@@ -0,0 +1,22 @@
+import { DataSource, Entity } from 'typeorm';
+import { AbstractErgoExtractorEntity } from '../lib';
+
+@Entity('test_entity')
+export class TestEntity extends AbstractErgoExtractorEntity {}
+
+/**
+ * generates a dataSource with in memory database for testing
+ */
+export const createDatabase = async (): Promise<DataSource> => {
+  const dataSource = new DataSource({
+    type: 'sqlite',
+    database: `:memory:`,
+    entities: [TestEntity],
+    migrations: [],
+    synchronize: true,
+    logging: false,
+  });
+  await dataSource.initialize();
+  await dataSource.runMigrations();
+  return dataSource;
+};