provide current position also inside backtest

Author: Haehnchen

src/dict/position.js

@@ -32,6 +32,10 @@ module.exports = class Position {
     this.raw = raw;
   }
 
+  getSide() {
+    return this.side;
+  }
+
   isShort() {
     return this.side === 'short';
   }

src/dict/strategy_context.js

@@ -6,18 +6,36 @@ module.exports = class StrategyContext {
     this.lastSignal = undefined;
     this.amount = undefined;
     this.entry = undefined;
+    this.profit = undefined;
   }
 
   static createFromPosition(ticker, position) {
     const context = new StrategyContext(ticker);
 
-    context.amount = position.amount;
-    context.lastSignal = position.amount < 0 ? 'short' : 'long';
-    context.entry = position.entry;
+    context.amount = position.getAmount();
+    context.lastSignal = position.getSide();
+    context.entry = position.getEntry();
+    context.profit = position.getProfit();
 
     return context;
   }
 
+  getAmount() {
+    return this.amount;
+  }
+
+  getLastSignal() {
+    return this.lastSignal;
+  }
+
+  getEntry() {
+    return this.entry;
+  }
+
+  getProfit() {
+    return this.profit;
+  }
+
   static create(ticker) {
     return new StrategyContext(ticker);
   }

src/modules/backtest.js

@@ -2,6 +2,7 @@ const moment = require('moment');
 const _ = require('lodash');
 const StrategyManager = require('./strategy/strategy_manager');
 const Resample = require('../utils/resample');
+const CommonUtil = require('../utils/common_util');
 
 module.exports = class Backtest {
   constructor(instances, strategyManager, exchangeCandleCombine, projectDir) {
@@ -101,7 +102,8 @@ module.exports = class Backtest {
           exchange,
           pair,
           options,
-          lastSignal.signal
+          lastSignal.signal,
+          lastSignal.price
         );
         item.time = current;
 
@@ -112,10 +114,8 @@ module.exports = class Backtest {
         }
 
         // position profit
-        if (lastSignal.signal === 'long' && lastSignal.price) {
-          item.profit = parseFloat(((item.price / lastSignal.price - 1) * 100).toFixed(2));
-        } else if (lastSignal.signal === 'short' && lastSignal.price) {
-          item.profit = parseFloat(((lastSignal.price / item.price - 1) * 100).toFixed(2));
+        if (lastSignal.price) {
+          item.profit = CommonUtil.getProfitAsPercent(lastSignal.signal, item.price, lastSignal.price);
         }
 
         if (['long', 'short'].includes(currentSignal)) {

src/modules/strategy/dict/indicator_period.js

@@ -9,11 +9,15 @@ module.exports = class IndicatorPeriod {
   }
 
   getLastSignal() {
-    if (!this.strategyContext || !this.strategyContext.lastSignal) {
+    if (!this.strategyContext || !this.strategyContext.getLastSignal()) {
       return undefined;
     }
 
-    return this.strategyContext.lastSignal;
+    return this.strategyContext.getLastSignal();
+  }
+
+  getProfit() {
+    return this.strategyContext.getProfit();
   }
 
   /**

src/modules/strategy/strategy_manager.js

@@ -5,9 +5,11 @@ const IndicatorBuilder = require('./dict/indicator_builder');
 const IndicatorPeriod = require('./dict/indicator_period');
 const ta = require('../../utils/technical_analysis');
 const Resample = require('../../utils/resample');
+const CommonUtil = require('../../utils/common_util');
 const StrategyContext = require('../../dict/strategy_context');
 const Ticker = require('../../dict/ticker');
 const SignalResult = require('./dict/signal_result');
+const Position = require('../../dict/position');
 
 module.exports = class StrategyManager {
   constructor(technicalAnalysisValidator, exchangeCandleCombine, logger, projectDir) {
@@ -94,16 +96,37 @@ module.exports = class StrategyManager {
    * @param symbol
    * @param options
    * @param lastSignal
+   * @param lastSignalEntry
    * @returns {Promise<array>}
    */
-  async executeStrategyBacktest(strategyName, exchange, symbol, options, lastSignal) {
+  async executeStrategyBacktest(strategyName, exchange, symbol, options, lastSignal, lastSignalEntry) {
     const results = await this.getTaResult(strategyName, exchange, symbol, options);
     if (!results || Object.keys(results).length === 0) {
       return {};
     }
 
     const price = results._candle ? results._candle.close : undefined;
-    const context = StrategyContext.create(new Ticker(exchange, symbol, undefined, price, price));
+
+    let context;
+    if (lastSignal && lastSignalEntry && price) {
+      // provide a suitable value; its just backtesting
+      const amount = lastSignal === 'short' ? -1 : 1;
+
+      context = StrategyContext.createFromPosition(
+        new Ticker(exchange, symbol, undefined, price, price),
+        new Position(
+          symbol,
+          lastSignal,
+          amount,
+          CommonUtil.getProfitAsPercent(lastSignal, price, lastSignalEntry),
+          undefined,
+          lastSignalEntry
+        )
+      );
+    } else {
+      context = StrategyContext.create(new Ticker(exchange, symbol, undefined, price, price));
+    }
+
     context.lastSignal = lastSignal;
 
     const indicatorPeriod = new IndicatorPeriod(context, results);

src/utils/common_util.js

@@ -0,0 +1,19 @@
+module.exports = {
+  /**
+   *
+   * @param {string} side
+   * @param {number} currentPrice
+   * @param {number} entryPrice
+   * @returns {number}
+   */
+  getProfitAsPercent: (side, currentPrice, entryPrice) => {
+    switch (side) {
+      case 'long':
+        return parseFloat(((currentPrice / entryPrice - 1) * 100).toFixed(2));
+      case 'short':
+        return parseFloat(((entryPrice / currentPrice - 1) * 100).toFixed(2));
+      default:
+        throw new Error(`Invalid direction given for profit ${side}`);
+    }
+  }
+};