@rosen-bridge/abstract-extractor 0.3.0 → 1.0.0

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',
@@ -100,8 +101,6 @@ export const extractedData = {
   boxId: 'boxId1',
   address: 'address1',
   serialized: 'serialized1',
-  blockId: 'blockId1',
-  height: 98,
 };
 
 export const block: Block = {
@@ -109,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;
+};