@quantform/core 0.3.233 → 0.3.239

package/src/ipc.spec.ts

@@ -0,0 +1,84 @@
+import { Session } from './session';
+import {
+  Adapter,
+  AdapterFeedCommand,
+  AdapterAwakeCommand,
+  AdapterAccountCommand,
+  AdapterSubscribeCommand,
+  AdapterDisposeCommand
+} from './adapter';
+import { PaperAdapter, PaperSpotExecutor } from './adapter/paper';
+import { PaperExecutor } from './adapter/paper/executor/paper-executor';
+import { ipcSub, run } from './ipc';
+import { Feed, InMemoryStorage } from './storage';
+import { instrumentOf } from './domain';
+import { handler } from './shared';
+
+class DefaultAdapter extends Adapter {
+  name = 'default';
+
+  timestamp() {
+    return 123;
+  }
+
+  createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
+    return new PaperSpotExecutor(adapter);
+  }
+
+  @handler(AdapterAwakeCommand)
+  onAwake(command: AdapterAwakeCommand) {}
+
+  @handler(AdapterDisposeCommand)
+  onDispose(command: AdapterDisposeCommand) {}
+
+  @handler(AdapterSubscribeCommand)
+  onSubscribe(command: AdapterSubscribeCommand) {}
+
+  @handler(AdapterAccountCommand)
+  onAccount(command: AdapterAccountCommand) {}
+
+  @handler(AdapterFeedCommand)
+  onFeed(command: AdapterFeedCommand) {}
+}
+
+describe('ipc feed tests', () => {
+  test('should trigger adapter feed command', async () => {
+    const command = {
+      type: 'feed',
+      instrument: 'default:btc-usdt',
+      from: 0,
+      to: 100
+    };
+
+    const session = await run(
+      {
+        adapter: [new DefaultAdapter()],
+        feed: new Feed(new InMemoryStorage()),
+        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt'))
+      },
+      command
+    );
+
+    expect(session.descriptor).toBeUndefined();
+  });
+
+  test('should dispatch session started event', done => {
+    const command = {
+      type: 'paper',
+      balance: { 'default:usd': 100 }
+    };
+
+    ipcSub.on('message', (message: any) => {
+      expect(message.type).toBe('paper:started');
+      done();
+    });
+
+    run(
+      {
+        adapter: [new DefaultAdapter()],
+        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt'))
+      },
+      command
+    );
+  });
+});

package/src/ipc.ts

@@ -4,8 +4,12 @@ import { instrumentOf } from './domain';
 import { Topic, event, handler } from './shared/topic';
 import { Logger } from './shared';
 import { backtest, idle, live, paper } from './bin';
+import { BacktesterStreamer } from './adapter/backtester';
+import { EventEmitter } from 'events';
 import minimist = require('minimist');
 
+export const ipcSub = new EventEmitter();
+
 /**
  * Base command/query interface for IPC communication.
  */
@@ -127,6 +131,11 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     accessor.session = live(this.descriptor);
 
+    this.notify({
+      type: 'live:started',
+      session: accessor.session.descriptor?.id
+    });
+
     await accessor.session.awake();
   }
 
@@ -143,6 +152,11 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
       balance: command.balance
     });
 
+    this.notify({
+      type: 'paper:started',
+      session: accessor.session.descriptor?.id
+    });
+
     await accessor.session.awake();
   }
 
@@ -156,28 +170,43 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
         from: command.from,
         to: command.to,
         balance: command.balance,
-        progress: timestamp =>
-          this.notify({
-            type: 'backtest:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          }),
-        completed: async () => {
-          const statement = {};
-
-          await accessor.session.dispose();
-
-          this.notify({ type: 'backtest:completed', statement });
-
-          resolve();
+        listener: {
+          onBacktestStarted: (streamer: BacktesterStreamer) => {
+            this.notify({
+              type: 'backtest:started',
+              session: session.descriptor?.id,
+              timestamp: streamer.timestamp,
+              from: command.from,
+              to: command.to
+            });
+          },
+          onBacktestUpdated: (streamer: BacktesterStreamer) => {
+            this.notify({
+              type: 'backtest:updated',
+              session: session.descriptor?.id,
+              timestamp: streamer.timestamp,
+              from: command.from,
+              to: command.to
+            });
+          },
+          onBacktestCompleted: async (streamer: BacktesterStreamer) => {
+            await accessor.session.dispose();
+
+            this.notify({
+              type: 'backtest:completed',
+              session: session.descriptor?.id,
+              timestamp: streamer.timestamp,
+              from: command.from,
+              to: command.to
+            });
+
+            resolve();
+          }
         }
       });
 
       accessor.session = session;
 
-      this.notify({ type: 'backtest:started' });
-
       await accessor.session.awake();
       await streamer.tryContinue().catch(it => Logger.error(it));
     });
@@ -229,11 +258,11 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    * Sends a message to parent process.
    */
   private notify(message: any) {
-    if (!process.send) {
-      return;
+    if (process.send) {
+      process.send(message);
     }
 
-    process.send(message);
+    ipcSub.emit('message', message);
   }
 }
 

package/src/session/session.ts

@@ -67,7 +67,7 @@ export class Session {
     // awake all adapters and synchronize trading accounts with store.
     await this.aggregate.awake(this.descriptor != null);
 
-    if (this.descriptor.describe) {
+    if (this.descriptor?.describe) {
       this.subscription = this.descriptor.describe(this).subscribe();
     }
   }

package/src/tests/backtester-adapter.spec.ts

@@ -69,12 +69,14 @@ describe('backtester adapter tests', () => {
       },
       from: 0,
       to: 100,
-      completed: () => {
-        expect(store.snapshot.timestamp).toEqual(1);
-        expect(store.snapshot.trade[instrument.toString()].rate).toEqual(100);
-        expect(store.snapshot.trade[instrument.toString()].quantity).toEqual(10);
+      listener: {
+        onBacktestCompleted: () => {
+          expect(store.snapshot.timestamp).toEqual(1);
+          expect(store.snapshot.trade[instrument.toString()].rate).toEqual(100);
+          expect(store.snapshot.trade[instrument.toString()].quantity).toEqual(10);
 
-        done();
+          done();
+        }
       }
     });