feat(models): add master-pair.repository spec

jest.config.js

@@ -18,7 +18,7 @@ module.exports = {
   testMatch: ['<rootDir>/modules/**/*.spec.ts', '<rootDir>/projects/**/*.spec.ts'],
   testURL: 'http://localhost/',
   collectCoverageFrom: ['modules/**/*.{js,ts}', 'projects/**/*.{js,ts}', '!projects/**/main.{js,ts}', '!modules/**/index.{js,ts}', '!**/node_modules/**', '!**/vendor/**'],
-  coveragePathIgnorePatterns: ['/node_modules/', '/test-helpers/', '/main.{js,ts}', '/dist/'],
+  coveragePathIgnorePatterns: ['/node_modules/', '/test-helpers/', '/main.{js,ts}', '/dist/', 'entity-test-bed'],
   coverageReporters: ['json', 'lcov'],
   verbose: true,
   preset: 'ts-jest',

modules/common/big-number-util/get-big-number.ts

@@ -6,6 +6,7 @@ export function getBigNumber(value: BigNumber.Value): BigNumber {
   try {
     bn = new BigNumber(value);
   } catch (e) {
+    /* istanbul ignore next */
     bn = new BigNumber(NaN);
   }
 

modules/exchanges/crypto/bitmex/websocket/internal/trade/trade.ts

@@ -28,7 +28,12 @@ export class Trade {
   tradeBin1d$(pair: string): Observable<TradeResponse> {
     const channel = getTradeChannel(pair, PublicEndPoints.TradeBin1d);
 
-    return this.ws.subscribe<TradeSource>(channel).pipe(map((wsData) => transform(wsData.data[0])));
+    return this.ws.subscribe<TradeSource>(channel).pipe(
+      map(
+        /* istanbul ignore next */
+        (wsData) => transform(wsData.data[0]),
+      ),
+    );
   }
 
   stopTradeBin1d(pair: string): void {

modules/models/common/testing/entity-test-bed/entity-test-bed.spec.ts

@@ -80,8 +80,8 @@ describe('EntityTestBed', () => {
 
         expect(overrideTimestampColumns(created)).toEqual([
           {
-            ...expectedBase,
             id: '1',
+            ...expectedBase,
           },
           {
             ...expectedBase,

modules/models/entity/master-pair/master-pair.entity.ts

@@ -71,7 +71,7 @@ export class MasterPairEntity {
     scale: 9,
     unsigned: true,
     comment: 'min Order amount',
-    default: () => '0.0',
+    default: /* istanbul ignore next */ () => '0.0',
     transformer: getFloorByDigitsTransformer(9),
   })
   readonly minOrderAmount!: Pair['minOrderAmount'];
@@ -91,7 +91,7 @@ export class MasterPairEntity {
     scale: 9,
     unsigned: true,
     comment: 'min Order price',
-    default: () => '0.0',
+    default: /* istanbul ignore next */ () => '0.0',
     transformer: getFloorByDigitsTransformer(9),
   })
   readonly minOrderPrice!: Pair['minOrderPrice'];
@@ -119,7 +119,7 @@ export class MasterPairEntity {
     type: 'datetime',
     name: 'created_at',
     precision: 3,
-    default: () => 'NOW(3)',
+    default: /* istanbul ignore next */ () => 'NOW(3)',
     transformer: nullableDateTransformer,
   })
   readonly createdAt!: Timestamp;
@@ -128,7 +128,7 @@ export class MasterPairEntity {
     type: 'datetime',
     name: 'updated_at',
     precision: 3,
-    default: () => 'NOW(3)',
+    default: /* istanbul ignore next */ () => 'NOW(3)',
     onUpdate: 'NOW(3)',
     transformer: nullableDateTransformer,
   })

modules/models/entity/master-pair/master-pair.repository.spec.ts

@@ -0,0 +1,88 @@
+import { EntityTestBed, MasterPairEntity, MasterPairEntityCreateParams, MasterPairRepository } from '@dripjs/models';
+import { getPairDefaultData } from '@dripjs/testing';
+
+describe('master-pair.repository', () => {
+  let masterPairReposity: MasterPairRepository;
+  const defaultData = getPairDefaultData();
+  const pair = 'xbtusd';
+
+  beforeAll(async () => {
+    await EntityTestBed.setup();
+    masterPairReposity = EntityTestBed.getRepository(MasterPairRepository);
+  });
+
+  afterAll(async () => {
+    await EntityTestBed.cleanup();
+  });
+
+  beforeEach(async () => {
+    await EntityTestBed.reset();
+    await masterPairReposity.insertNewPairs(defaultData);
+  });
+
+  describe('insertNewPair', () => {
+    it('should insert new pair', async () => {
+      const newData = {
+        ...defaultData[0],
+        name: 'ethusd',
+        quoteAsset: 'usd',
+        baseAsset: 'eth',
+      };
+      await masterPairReposity.insertNewPair(newData);
+      const insertedPairs = await masterPairReposity.find({
+        name: newData.name,
+      });
+      expect(insertedPairs.map(getDataFromEntity)).toEqual([newData]);
+    });
+  });
+
+  describe('insertNewPairs', () => {
+    it('should insert new pairs', async () => {
+      const insertedPairs = await masterPairReposity.find();
+      expect(insertedPairs.map(getDataFromEntity)).toEqual(defaultData);
+    });
+  });
+
+  describe('findByPair', () => {
+    it('should find by pair', async () => {
+      const existed = await masterPairReposity.findByPair(pair);
+      expect(existed).toBeDefined();
+      expect(getDataFromEntity(existed!)).toEqual(defaultData[0]);
+    });
+  });
+
+  describe('getPair', () => {
+    it('should get pair', async () => {
+      const pairInfo = await masterPairReposity.getPair();
+      expect([getDataFromEntity(pairInfo[0])]).toEqual(defaultData);
+    });
+  });
+
+  describe('getPairNames', () => {
+    it('should get pair names', async () => {
+      const pairNames = await masterPairReposity.getPairNames();
+      expect(pairNames).toEqual(defaultData.map((o) => o.name));
+    });
+  });
+
+  describe('getPrecisionByPair', () => {
+    it('should get precision by pair', async () => {
+      const prec = await masterPairReposity.getPrecisionByPair(pair);
+      expect(prec).toEqual({ pricePrecision: 1, amountPrecision: 0 });
+    });
+  });
+});
+
+function getDataFromEntity(entity: MasterPairEntity): MasterPairEntityCreateParams {
+  return {
+    exchange: entity.exchange,
+    name: entity.name,
+    baseAsset: entity.baseAsset,
+    quoteAsset: entity.quoteAsset,
+    amountPrecision: entity.amountPrecision,
+    pricePrecision: entity.pricePrecision,
+    maxOrderAmount: entity.maxOrderAmount,
+    maxOrderPrice: entity.maxOrderPrice,
+    isEnabled: entity.isEnabled,
+  };
+}

modules/models/entity/master-pair/master-pair.repository.ts

@@ -3,11 +3,15 @@ import { EntityRepository, Repository } from 'typeorm';
 import { MasterPairEntity } from './master-pair.entity';
 
 export interface MasterPairEntityCreateParams {
+  exchange: MasterPairEntity['exchange'];
   name: MasterPairEntity['name'];
   baseAsset: MasterPairEntity['baseAsset'];
   quoteAsset: MasterPairEntity['quoteAsset'];
   amountPrecision: MasterPairEntity['amountPrecision'];
   pricePrecision: MasterPairEntity['pricePrecision'];
+  maxOrderAmount: MasterPairEntity['maxOrderAmount'];
+  maxOrderPrice: MasterPairEntity['maxOrderPrice'];
+  isEnabled: MasterPairEntity['isEnabled'];
 }
 
 export interface PairPrecision {
@@ -44,10 +48,6 @@ export class MasterPairRepository extends Repository<MasterPairEntity> {
     return this.find({ where: { isEnabled: true } });
   }
 
-  async getVisiblePairs(): Promise<MasterPairEntity[]> {
-    return this.find({ where: { isEnabled: true } });
-  }
-
   async getPairNames(): Promise<string[]> {
     const rs: { name: string }[] = await this.createQueryBuilder()
       .select('name')

modules/testing/data/exchanges/index.ts

@@ -0,0 +1 @@
+export * from './bitmex';

modules/testing/data/index.ts

@@ -1 +1,2 @@
-export * from './bitmex';
+export * from './exchanges';
+export * from './models';

modules/testing/data/models/index.ts

@@ -0,0 +1 @@
+export * from './master-pair.entity';

modules/testing/data/models/master-pair.entity.ts

@@ -0,0 +1,18 @@
+import { MasterPairEntityCreateParams } from '@dripjs/models';
+
+// use function to avoid object mutating when insert to db
+export function getPairDefaultData(): MasterPairEntityCreateParams[] {
+  return [
+    {
+      exchange: 'bitmex',
+      name: 'xbtusd',
+      baseAsset: 'xbt',
+      quoteAsset: 'usd',
+      amountPrecision: 0,
+      pricePrecision: 1,
+      maxOrderAmount: 9999999,
+      maxOrderPrice: 9999999,
+      isEnabled: true,
+    },
+  ];
+}