Add unit, integration tests & Github CI workflow

.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: ci
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+
+jobs:
+ ci:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v3
+ - run: corepack enable
+ - uses: actions/setup-node@v3
+ with:
+ node-version: 16
+ cache: 'pnpm'
+ - run: pnpm install
+ - run: pnpm build
+ - run: pnpm format:check
+ - run: pnpm lint
+ - run: pnpm build
+ - run: pnpm test
+ - uses: codecov/codecov-action@v3

package.json

@@ -8,11 +8,12 @@
  "scripts": {
  "build": "nest build",
  "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+ "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
  "start": "nest start",
  "start:dev": "nest start --watch",
  "start:debug": "nest start --debug --watch",
  "start:prod": "node dist/main",
- "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+ "lint": "eslint \"src/**/*.ts\" --fix",
  "test": "jest",
  "test:watch": "jest --watch",
  "test:cov": "jest --coverage",
@@ -72,6 +73,9 @@
  "**/*.(t|j)s"
  ],
  "coverageDirectory": "../coverage",
- "testEnvironment": "node"
+ "testEnvironment": "node",
+ "moduleNameMapper": {
+ "^src/(.*)$": "<rootDir>/$1"
+ }
  }
 }

src/app.module.spec.ts

@@ -0,0 +1,44 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppModule } from './app.module';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+import { XTransferModule } from './x-transfer/x-transfer.module';
+import { AssetsModule } from './assets/assets.module';
+import { ChannelsModule } from './channels/channels.module';
+import { PalletsModule } from './pallets/pallets.module';
+
+describe('AppModule', () => {
+ let appModule: TestingModule;
+
+ beforeAll(async () => {
+ appModule = await Test.createTestingModule({
+ imports: [AppModule],
+ }).compile();
+ });
+
+ it('should be defined', () => {
+ expect(appModule).toBeDefined();
+ });
+
+ it('should have the correct controllers', () => {
+ const controllers = appModule.get<AppController>(AppController);
+ expect(controllers).toBeDefined();
+ });
+
+ it('should have the correct providers', () => {
+ const providers = appModule.get<AppService>(AppService);
+ expect(providers).toBeDefined();
+ });
+
+ it('should have the correct module imports', () => {
+ const xTransferModule = appModule.select(XTransferModule);
+ const assetsModule = appModule.select(AssetsModule);
+ const channelsModule = appModule.select(ChannelsModule);
+ const palletsModule = appModule.select(PalletsModule);
+
+ expect(xTransferModule).toBeDefined();
+ expect(assetsModule).toBeDefined();
+ expect(channelsModule).toBeDefined();
+ expect(palletsModule).toBeDefined();
+ });
+});

src/assets/assets.controller.spec.ts

@@ -1,9 +1,15 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AssetsController } from './assets.controller';
 import { AssetsService } from './assets.service';
+import { TNode } from '@paraspell/sdk';
 
+// Integration tests to ensure controller and service are working together
 describe('AssetsController', () => {
  let controller: AssetsController;
+ let assetsService: AssetsService;
+ const node: TNode = 'Acala';
+ const symbol = 'KSM';
+ const decimals = 18;
 
  beforeEach(async () => {
  const module: TestingModule = await Test.createTestingModule({
@@ -12,9 +18,177 @@ describe('AssetsController', () => {
  }).compile();
 
  controller = module.get<AssetsController>(AssetsController);
+ assetsService = module.get<AssetsService>(AssetsService);
  });
 
  it('should be defined', () => {
  expect(controller).toBeDefined();
  });
+
+ describe('getNodeNames', () => {
+ it('should return the list of node names', () => {
+ const mockResult = ['Acala', 'Basilisk'];
+ jest
+ .spyOn(assetsService, 'getNodeNames' as any)
+ .mockReturnValue(mockResult);
+
+ const result = controller.getNodeNames();
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getNodeNames).toHaveBeenCalled();
+ });
+ });
+
+ describe('getNodeNames', () => {
+ it('should return the list of node names', () => {
+ const mockResult = [node, 'Basilisk'];
+ jest
+ .spyOn(assetsService, 'getNodeNames' as any)
+ .mockReturnValue(mockResult);
+
+ const result = controller.getNodeNames();
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getNodeNames).toHaveBeenCalled();
+ });
+ });
+
+ describe('getAssetsObject', () => {
+ const mockResult = {
+ paraId: 2009,
+ relayChainAssetSymbol: 'KSM',
+ nativeAssets: [{ symbol, decimals }],
+ otherAssets: [{ assetId: '234123123', symbol: 'FKK', decimals }],
+ };
+ it('should return assets object for a valid node', () => {
+ jest
+ .spyOn(assetsService, 'getAssetsObject' as any)
+ .mockReturnValue(mockResult);
+
+ const result = controller.getAssetsObject(node);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getAssetsObject).toHaveBeenCalledWith(node);
+ });
+
+ it('should return assets object for a valid parachain id', () => {
+ const paraId = '2009';
+ jest
+ .spyOn(assetsService, 'getNodeByParaId' as any)
+ .mockReturnValue(mockResult);
+
+ const result = controller.getAssetsObject(paraId);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getNodeByParaId).toHaveBeenCalledWith(
+ Number(paraId),
+ );
+ });
+ });
+
+ describe('getAssetId', () => {
+ it('should return asset ID for a valid node and symbol', () => {
+ const symbol = 'DOT';
+ const mockResult = '1';
+ jest.spyOn(assetsService, 'getAssetId').mockReturnValue(mockResult);
+
+ const result = controller.getAssetId(node, symbol);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getAssetId).toHaveBeenCalledWith(node, symbol);
+ });
+ });
+
+ describe('getRelayChainSymbol', () => {
+ it('should return relay chain symbol for a valid node', () => {
+ const mockResult = 'KSM';
+ jest
+ .spyOn(assetsService, 'getRelayChainSymbol')
+ .mockReturnValue(mockResult);
+
+ const result = controller.getRelayChainSymbol(node);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getRelayChainSymbol).toHaveBeenCalledWith(node);
+ });
+ });
+
+ describe('getNativeAssets', () => {
+ it('should return native assets for a valid node', () => {
+ const mockResult = [{ symbol, decimals }];
+ jest.spyOn(assetsService, 'getNativeAssets').mockReturnValue(mockResult);
+
+ const result = controller.getNativeAssets(node);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getNativeAssets).toHaveBeenCalledWith(node);
+ });
+ });
+
+ describe('getOtherAssets', () => {
+ it('should return other assets for a valid node', () => {
+ const mockResult = [{ assetId: '234123123', symbol: 'FKK', decimals }];
+ jest.spyOn(assetsService, 'getOtherAssets').mockReturnValue(mockResult);
+
+ const result = controller.getOtherAssets(node);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getOtherAssets).toHaveBeenCalledWith(node);
+ });
+ });
+
+ describe('getAllAssetsSymbol', () => {
+ it('should return all assets symbols for a valid node', () => {
+ const mockResult = [symbol, 'DOT'];
+ jest
+ .spyOn(assetsService, 'getAllAssetsSymbols')
+ .mockReturnValue(mockResult);
+
+ const result = controller.getAllAssetsSymbol(node);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getAllAssetsSymbols).toHaveBeenCalledWith(node);
+ });
+ });
+
+ describe('getDecimals', () => {
+ it('should return decimals for a valid node and symbol', () => {
+ const mockResult = 18;
+ jest.spyOn(assetsService, 'getDecimals').mockReturnValue(mockResult);
+
+ const result = controller.getDecimals(node, symbol);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getDecimals).toHaveBeenCalledWith(node, symbol);
+ });
+ });
+
+ describe('hasSupportForAsset', () => {
+ it('should return true if asset is supported for a valid node and symbol', () => {
+ const mockResult = true;
+ jest
+ .spyOn(assetsService, 'hasSupportForAsset')
+ .mockReturnValue(mockResult);
+
+ const result = controller.hasSupportForAsset(node, symbol);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.hasSupportForAsset).toHaveBeenCalledWith(
+ node,
+ symbol,
+ );
+ });
+ });
+
+ describe('getParaId', () => {
+ it('should return parachain id for a valid node', () => {
+ const mockResult = 2009;
+ jest.spyOn(assetsService, 'getParaId').mockReturnValue(mockResult);
+
+ const result = controller.getParaId(node);
+
+ expect(result).toBe(mockResult);
+ expect(assetsService.getParaId).toHaveBeenCalledWith(node);
+ });
+ });
 });

src/assets/assets.controller.ts

@@ -1,4 +1,4 @@
-import { Controller, Get, Param, Query } from '@nestjs/common';
+import { Controller, Get, Param } from '@nestjs/common';
 import { AssetsService } from './assets.service';
 import { isNumeric } from 'src/utils';
 
@@ -46,7 +46,7 @@ export class AssetsController {
  }
 
  @Get(':node/decimals/:symbol')
- decimals(@Param('node') node: string, @Param('symbol') symbol: string) {
+ getDecimals(@Param('node') node: string, @Param('symbol') symbol: string) {
  return this.assetsService.getDecimals(node, symbol);
  }
 

src/assets/assets.module.ts

@@ -4,6 +4,6 @@ import { AssetsController } from './assets.controller';
 
 @Module({
  controllers: [AssetsController],
- providers: [AssetsService]
+ providers: [AssetsService],
 })
 export class AssetsModule {}