client unit tests

src/models/StratumV1Client.spec.ts

@@ -1,21 +1,44 @@
 import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { TypeOrmModule } from '@nestjs/typeorm';
 import { PromiseSocket } from 'promise-socket';
+import { BehaviorSubject } from 'rxjs';
+import { DataSource } from 'typeorm';
 
+import { MockRecording1 } from '../../test/models/MockRecording1';
 import { BlocksService } from '../ORM/blocks/blocks.service';
+import { ClientStatisticsEntity } from '../ORM/client-statistics/client-statistics.entity';
+import { ClientStatisticsModule } from '../ORM/client-statistics/client-statistics.module';
 import { ClientStatisticsService } from '../ORM/client-statistics/client-statistics.service';
+import { ClientEntity } from '../ORM/client/client.entity';
+import { ClientModule } from '../ORM/client/client.module';
 import { ClientService } from '../ORM/client/client.service';
-import { BitcoinRpcService } from '../services/bitcoin-rpc.service';
+import { BitcoinRpcService as MockBitcoinRpcService } from '../services/bitcoin-rpc.service';
 import { BlockTemplateService } from '../services/block-template.service';
 import { NotificationService } from '../services/notification.service';
 import { StratumV1JobsService } from '../services/stratum-v1-jobs.service';
+import { IMiningInfo } from './bitcoin-rpc/IMiningInfo';
 import { StratumV1Client } from './StratumV1Client';
 
 
+
+
+
+jest.mock('../services/bitcoin-rpc.service')
+
+jest.mock('./validators/bitcoin-address.validator', () => ({
+    IsBitcoinAddress() {
+        return jest.fn();
+    },
+}));
+
+
 describe('StratumV1Client', () => {
 
-    let promiseSocket: PromiseSocket<any> = new PromiseSocket();
-    let stratumV1JobsService: StratumV1JobsService;
-    let bitcoinRpcService: BitcoinRpcService;
+
+    let promiseSocket: PromiseSocket<any>;
+    let stratumV1JobsService: StratumV1JobsService = new StratumV1JobsService();
+    let bitcoinRpcService: MockBitcoinRpcService;
     let blockTemplateService: BlockTemplateService;
     let clientService: ClientService;
     let clientStatisticsService: ClientStatisticsService;
@@ -25,10 +48,79 @@ describe('StratumV1Client', () => {
 
     let client: StratumV1Client;
 
+    let socketEmitter: (data: Buffer) => void;
+
+    let newBlockEmitter: BehaviorSubject<IMiningInfo> = new BehaviorSubject(null);
+
+    let moduleRef: TestingModule;
+
+    beforeAll(async () => {
+        moduleRef = await Test.createTestingModule({
+            imports: [
+                TypeOrmModule.forRoot({
+                    type: 'sqlite',
+                    database: './DB/public-pool.test.sqlite',
+                    synchronize: true,
+                    autoLoadEntities: true,
+                    cache: true,
+                    logging: false
+                }),
+                ClientModule,
+                ClientStatisticsModule
+            ],
+            providers: [
+                {
+                    provide: ConfigService,
+                    useValue: {
+                        get: jest.fn((key: string) => {
+                            switch (key) {
+                                case 'DEV_FEE_ADDRESS':
+                                    return 'tb1qumezefzdeqqwn5zfvgdrhxjzc5ylr39uhuxcz4';
+                                case 'NETWORK':
+                                    return 'testnet';
+                            }
+                            return null;
+                        })
+                    }
+                }
+            ],
+        }).compile();
+
+
+    })
+
 
     beforeEach(async () => {
 
-        jest.spyOn(promiseSocket.socket, 'on').mockImplementation();
+
+
+        clientService = moduleRef.get<ClientService>(ClientService);
+
+        const dataSource = moduleRef.get<DataSource>(DataSource);
+
+        dataSource.getRepository(ClientEntity).delete({});
+        dataSource.getRepository(ClientStatisticsEntity).delete({});
+
+
+        clientStatisticsService = moduleRef.get<ClientStatisticsService>(ClientStatisticsService);
+
+        configService = moduleRef.get<ConfigService>(ConfigService);
+
+        bitcoinRpcService = new MockBitcoinRpcService(null);
+
+        jest.spyOn(bitcoinRpcService, 'getBlockTemplate').mockReturnValue(Promise.resolve(MockRecording1.BLOCK_TEMPLATE));
+        bitcoinRpcService.newBlock$ = newBlockEmitter.asObservable();
+
+        blockTemplateService = new BlockTemplateService(bitcoinRpcService);
+
+
+        promiseSocket = new PromiseSocket();
+        jest.spyOn(promiseSocket.socket, 'on').mockImplementation((event: string, fn: (data: Buffer) => void) => {
+            socketEmitter = fn;
+        });
+
+        promiseSocket.end = jest.fn();
+
 
         client = new StratumV1Client(
             promiseSocket,
@@ -42,12 +134,126 @@ describe('StratumV1Client', () => {
             configService
         );
 
+        client.extraNonceAndSessionId = MockRecording1.EXTRA_NONCE;
+
+        jest.useFakeTimers({ advanceTimers: true })
+    });
+
+    afterEach(async () => {
+        client.destroy();
+        jest.useRealTimers();
+    })
+
+
+    it('should subscribe to socket', () => {
+        expect(promiseSocket.socket.on).toHaveBeenCalled();
+    });
+
+    it('should close socket on invalid JSON', () => {
+        socketEmitter(Buffer.from('INVALID'));
+        expect(promiseSocket.end).toHaveBeenCalledTimes(1);
+    });
+
+    it('should respond to mining.subscribe', async () => {
+        jest.spyOn(promiseSocket, 'write').mockImplementation((data) => Promise.resolve(1));
+
+        expect(promiseSocket.socket.on).toHaveBeenCalled();
+        socketEmitter(Buffer.from(MockRecording1.MINING_SUBSCRIBE));
+
+        await new Promise((r) => setTimeout(r, 1));
+
+        expect(promiseSocket.write).toHaveBeenCalledWith(`{"id":1,"error":null,"result":[[["mining.notify","${client.extraNonceAndSessionId}"]],"${client.extraNonceAndSessionId}",4]}\n`);
 
     });
 
 
-    it('should parse message', () => {
+    it('should respond to mining.configure', async () => {
+
+        jest.spyOn(promiseSocket, 'write').mockImplementation((data) => Promise.resolve(1));
+
         expect(promiseSocket.socket.on).toHaveBeenCalled();
+        socketEmitter(Buffer.from(MockRecording1.MINING_CONFIGURE));
+        await new Promise((r) => setTimeout(r, 1));
+        expect(promiseSocket.write).toHaveBeenCalledWith(`{"id":2,"error":null,"result":{"version-rolling":true,"version-rolling.mask":"1fffe000"}}\n`);
+    });
+
+    it('should respond to mining.authorize', async () => {
+
+        jest.spyOn(promiseSocket, 'write').mockImplementation((data) => Promise.resolve(1));
+
+        expect(promiseSocket.socket.on).toHaveBeenCalled();
+        socketEmitter(Buffer.from(MockRecording1.MINING_AUTHORIZE));
+        await new Promise((r) => setTimeout(r, 1));
+        expect(promiseSocket.write).toHaveBeenCalledWith('{"id":3,"error":null,"result":true}\n');
+    });
+
+    it('should respond to mining.suggest_difficulty', async () => {
+        jest.spyOn(promiseSocket, 'write').mockImplementation((data) => Promise.resolve(1));
+
+        expect(promiseSocket.socket.on).toHaveBeenCalled();
+        socketEmitter(Buffer.from(MockRecording1.MINING_SUGGEST_DIFFICULTY));
+        await new Promise((r) => setTimeout(r, 1));
+        expect(promiseSocket.write).toHaveBeenCalledWith(`{"id":4,"method":"mining.set_difficulty","params":[512]}\n`);
+    });
+
+    it('should set difficulty', async () => {
+        jest.spyOn(promiseSocket, 'write').mockImplementation((data) => Promise.resolve(1));
+
+        socketEmitter(Buffer.from(MockRecording1.MINING_SUBSCRIBE));
+        socketEmitter(Buffer.from(MockRecording1.MINING_AUTHORIZE));
+        await new Promise((r) => setTimeout(r, 100));
+
+        expect(promiseSocket.write).toHaveBeenCalledWith(`{"id":null,"method":"mining.set_difficulty","params":[32768]}\n`);
+
+    });
+
+    it('should save client', async () => {
+        jest.spyOn(promiseSocket, 'write').mockImplementation((data) => Promise.resolve(1));
+
+        socketEmitter(Buffer.from(MockRecording1.MINING_SUBSCRIBE));
+        socketEmitter(Buffer.from(MockRecording1.MINING_AUTHORIZE));
+        await new Promise((r) => setTimeout(r, 100));
+
+        const clientCount = await clientService.connectedClientCount();
+        expect(clientCount).toBe(1);
+
+    });
+
+
+
+
+    it('should send job and accept submission', async () => {
+
+
+
+        const date = new Date(parseInt(MockRecording1.TIME, 16) * 1000);
+
+
+        jest.setSystemTime(date);
+
+        jest.spyOn(promiseSocket, 'write').mockImplementation((data) => Promise.resolve(1));
+
+
+        socketEmitter(Buffer.from(MockRecording1.MINING_SUBSCRIBE));
+        socketEmitter(Buffer.from(MockRecording1.MINING_SUGGEST_DIFFICULTY));
+        socketEmitter(Buffer.from(MockRecording1.MINING_AUTHORIZE));
+
+
+
+        await new Promise((r) => setTimeout(r, 100));
+
+
+
+
+        expect(promiseSocket.write).lastCalledWith(`{"id":null,"method":"mining.notify","params":["3","171592f223740e92d223f6e68bff25279af7ac4f2246451e0000000200000000","02000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1903c943255c7075626c69632d706f6f6c5c","ffffffff037a90000000000000160014e6f22ca44dc800e9d049621a3b9a42c509f1c4bc3b0f250000000000160014e6f22ca44dc800e9d049621a3b9a42c509f1c4bc0000000000000000266a24aa21a9edbd3d1d916aa0b57326a2d88ebe1b68a1d7c48585f26d8335fe6a94b62755f64c00000000",["175335649d5e8746982969ec88f52e85ac9917106fba5468e699c8879ab974a1","d5644ab3e708c54cd68dc5aedc92b8d3037449687f92ec41ed6e37673d969d4a","5c9ec187517edc0698556cca5ce27e54c96acb014770599ed9df4d4937fbf2b0"],"20000000","192495f8","${MockRecording1.TIME}",false]}\n`);
+
+
+        socketEmitter(Buffer.from(MockRecording1.MINING_SUBMIT));
+
+        jest.useRealTimers();
+        await new Promise((r) => setTimeout(r, 100));
+
+
     });