Merge with develop

freqtrade/analyze.py

@@ -62,6 +62,7 @@ class Analyze(object):
             'close': 'last',
             'volume': 'max',
         })
+        frame.drop(frame.tail(1).index, inplace=True)     # eliminate partial candle
         return frame
 
     def populate_indicators(self, dataframe: DataFrame) -> DataFrame:

freqtrade/arguments.py

@@ -72,7 +72,7 @@ class Arguments(object):
         self.parser.add_argument(
             '--version',
             action='version',
-            version='%(prog)s {}'.format(__version__),
+            version=f'%(prog)s {__version__}'
         )
         self.parser.add_argument(
             '-c', '--config',
@@ -165,6 +165,11 @@ class Arguments(object):
 
     @staticmethod
     def optimizer_shared_options(parser: argparse.ArgumentParser) -> None:
+        """
+        Parses given common arguments for Backtesting and Hyperopt scripts.
+        :param parser:
+        :return:
+        """
         parser.add_argument(
             '-i', '--ticker-interval',
             help='specify ticker interval (1m, 5m, 30m, 1h, 1d)',
@@ -243,7 +248,7 @@ class Arguments(object):
         :return: Start and End range period
         """
         if text is None:
-            return TimeRange()
+            return TimeRange(None, None, 0, 0)
         syntax = [(r'^-(\d{8})$', (None, 'date')),
                   (r'^(\d{8})-$', ('date', None)),
                   (r'^(\d{8})-(\d{8})$', ('date', 'date')),
@@ -296,28 +301,34 @@ class Arguments(object):
             '--pairs-file',
             help='File containing a list of pairs to download',
             dest='pairs_file',
-            default=None
+            default=None,
+            metavar='PATH',
         )
 
         self.parser.add_argument(
             '--export',
             help='Export files to given dir',
             dest='export',
-            default=None)
+            default=None,
+            metavar='PATH',
+        )
 
         self.parser.add_argument(
             '--days',
             help='Download data for number of days',
             dest='days',
             type=int,
-            default=None)
+            metavar='INT',
+            default=None
+        )
 
         self.parser.add_argument(
             '--exchange',
             help='Exchange name (default: %(default)s)',
             dest='exchange',
             type=str,
-            default='bittrex')
+            default='bittrex'
+        )
 
         self.parser.add_argument(
             '-t', '--timeframes',

freqtrade/configuration.py

@@ -61,11 +61,9 @@ class Configuration(object):
             with open(path) as file:
                 conf = json.load(file)
         except FileNotFoundError:
-            logger.critical(
-                'Config file "%s" not found. Please create your config file',
-                path
-            )
-            exit(0)
+            raise OperationalException(
+                'Config file "{}" not found!'
+                ' Please create a config file or check whether it exists.'.format(path))
 
         if 'internals' not in conf:
             conf['internals'] = {}
@@ -238,9 +236,8 @@ class Configuration(object):
         exchange = config.get('exchange', {}).get('name').lower()
         if exchange not in ccxt.exchanges:
 
-            exception_msg = 'Exchange "{}" not supported.\n' \
-                            'The following exchanges are supported: {}'\
-                .format(exchange, ', '.join(ccxt.exchanges))
+            exception_msg = f'Exchange "{exchange}" not supported.\n' \
+                            f'The following exchanges are supported: {", ".join(ccxt.exchanges)}'
 
             logger.critical(exception_msg)
             raise OperationalException(

freqtrade/exchange/__init__.py

@@ -59,7 +59,7 @@ def init_ccxt(exchange_config: dict) -> ccxt.Exchange:
     name = exchange_config['name']
 
     if name not in ccxt.exchanges:
-        raise OperationalException('Exchange {} is not supported'.format(name))
+        raise OperationalException(f'Exchange {name} is not supported')
     try:
         api = getattr(ccxt, name.lower())({
             'apiKey': exchange_config.get('key'),
@@ -69,7 +69,7 @@ def init_ccxt(exchange_config: dict) -> ccxt.Exchange:
             'enableRateLimit': True,
         })
     except (KeyError, AttributeError):
-        raise OperationalException('Exchange {} is not supported'.format(name))
+        raise OperationalException(f'Exchange {name} is not supported')
 
     return api
 
@@ -118,11 +118,10 @@ def validate_pairs(pairs: List[str]) -> None:
         # TODO: add a support for having coins in BTC/USDT format
         if not pair.endswith(stake_cur):
             raise OperationalException(
-                'Pair {} not compatible with stake_currency: {}'.format(pair, stake_cur)
-            )
+                f'Pair {pair} not compatible with stake_currency: {stake_cur}')
         if pair not in markets:
             raise OperationalException(
-                'Pair {} is not available at {}'.format(pair, get_name()))
+                f'Pair {pair} is not available at {get_name()}')
 
 
 def exchange_has(endpoint: str) -> bool:
@@ -138,7 +137,7 @@ def exchange_has(endpoint: str) -> bool:
 def buy(pair: str, rate: float, amount: float) -> Dict:
     if _CONF['dry_run']:
         global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_buy_{}'.format(randint(0, 10**6))
+        order_id = f'dry_run_buy_{randint(0, 10**6)}'
         _DRY_RUN_OPEN_ORDERS[order_id] = {
             'pair': pair,
             'price': rate,
@@ -156,20 +155,17 @@ def buy(pair: str, rate: float, amount: float) -> Dict:
         return _API.create_limit_buy_order(pair, amount, rate)
     except ccxt.InsufficientFunds as e:
         raise DependencyException(
-            'Insufficient funds to create limit buy order on market {}.'
-            'Tried to buy amount {} at rate {} (total {}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
-        )
+            f'Insufficient funds to create limit buy order on market {pair}.'
+            f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+            f'Message: {e}')
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not create limit buy order on market {}.'
-            'Tried to buy amount {} at rate {} (total {}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
-        )
+            f'Could not create limit buy order on market {pair}.'
+            f'Tried to buy amount {amount} at rate {rate} (total {rate*amount}).'
+            f'Message: {e}')
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not place buy order due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not place buy order due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -177,7 +173,7 @@ def buy(pair: str, rate: float, amount: float) -> Dict:
 def sell(pair: str, rate: float, amount: float) -> Dict:
     if _CONF['dry_run']:
         global _DRY_RUN_OPEN_ORDERS
-        order_id = 'dry_run_sell_{}'.format(randint(0, 10**6))
+        order_id = f'dry_run_sell_{randint(0, 10**6)}'
         _DRY_RUN_OPEN_ORDERS[order_id] = {
             'pair': pair,
             'price': rate,
@@ -194,20 +190,17 @@ def sell(pair: str, rate: float, amount: float) -> Dict:
         return _API.create_limit_sell_order(pair, amount, rate)
     except ccxt.InsufficientFunds as e:
         raise DependencyException(
-            'Insufficient funds to create limit sell order on market {}.'
-            'Tried to sell amount {} at rate {} (total {}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
-        )
+            f'Insufficient funds to create limit sell order on market {pair}.'
+            f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
+            f'Message: {e}')
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not create limit sell order on market {}.'
-            'Tried to sell amount {} at rate {} (total {}).'
-            'Message: {}'.format(pair, amount, rate, rate*amount, e)
-        )
+            f'Could not create limit sell order on market {pair}.'
+            f'Tried to sell amount {amount} at rate {rate} (total {rate*amount}).'
+            f'Message: {e}')
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not place sell order due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not place sell order due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -222,8 +215,7 @@ def get_balance(currency: str) -> float:
     balance = balances.get(currency)
     if balance is None:
         raise TemporaryError(
-            'Could not get {} balance due to malformed exchange response: {}'.format(
-                currency, balances))
+            f'Could not get {currency} balance due to malformed exchange response: {balances}')
     return balance['free']
 
 
@@ -243,8 +235,7 @@ def get_balances() -> dict:
         return balances
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not get balance due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not get balance due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -255,13 +246,11 @@ def get_tickers() -> Dict:
         return _API.fetch_tickers()
     except ccxt.NotSupported as e:
         raise OperationalException(
-            'Exchange {} does not support fetching tickers in batch.'
-            'Message: {}'.format(_API.name, e)
-        )
+            f'Exchange {_API.name} does not support fetching tickers in batch.'
+            f'Message: {e}')
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not load tickers due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not load tickers due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -277,13 +266,12 @@ def get_ticker(pair: str, refresh: Optional[bool] = True) -> dict:
                     'bid': float(data['bid']),
                     'ask': float(data['ask']),
                 }
-            except KeyError as e:
+            except KeyError:
                 logger.debug("Could not cache ticker data for %s", pair)
             return data
         except (ccxt.NetworkError, ccxt.ExchangeError) as e:
             raise TemporaryError(
-                'Could not load ticker history due to {}. Message: {}'.format(
-                    e.__class__.__name__, e))
+                f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
         except ccxt.BaseError as e:
             raise OperationalException(e)
     else:
@@ -327,15 +315,13 @@ def get_ticker_history(pair: str, tick_interval: str, since_ms: Optional[int] =
         return data
     except ccxt.NotSupported as e:
         raise OperationalException(
-            'Exchange {} does not support fetching historical candlestick data.'
-            'Message: {}'.format(_API.name, e)
-        )
+            f'Exchange {_API.name} does not support fetching historical candlestick data.'
+            f'Message: {e}')
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not load ticker history due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not load ticker history due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
-        raise OperationalException('Could not fetch ticker data. Msg: {}'.format(e))
+        raise OperationalException(f'Could not fetch ticker data. Msg: {e}')
 
 
 @retrier
@@ -347,12 +333,10 @@ def cancel_order(order_id: str, pair: str) -> None:
         return _API.cancel_order(order_id, pair)
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not cancel order. Message: {}'.format(e)
-        )
+            f'Could not cancel order. Message: {e}')
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not cancel order due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not cancel order due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -369,12 +353,10 @@ def get_order(order_id: str, pair: str) -> Dict:
         return _API.fetch_order(order_id, pair)
     except ccxt.InvalidOrder as e:
         raise DependencyException(
-            'Could not get order. Message: {}'.format(e)
-        )
+            f'Could not get order. Message: {e}')
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not get order due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not get order due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -393,8 +375,7 @@ def get_trades_for_order(order_id: str, pair: str, since: datetime) -> List:
 
     except ccxt.NetworkError as e:
         raise TemporaryError(
-            'Could not get trades due to networking error. Message: {}'.format(e)
-        )
+            f'Could not get trades due to networking error. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -416,8 +397,7 @@ def get_markets() -> List[dict]:
         return _API.fetch_markets()
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not load markets due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not load markets due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 
@@ -442,8 +422,7 @@ def get_fee(symbol='ETH/BTC', type='', side='', amount=1,
                                   price=price, takerOrMaker=taker_or_maker)['rate']
     except (ccxt.NetworkError, ccxt.ExchangeError) as e:
         raise TemporaryError(
-            'Could not get fee info due to {}. Message: {}'.format(
-                e.__class__.__name__, e))
+            f'Could not get fee info due to {e.__class__.__name__}. Message: {e}')
     except ccxt.BaseError as e:
         raise OperationalException(e)
 

freqtrade/fiat_convert.py

@@ -119,7 +119,7 @@ class CryptoToFiatConverter(object):
 
         # Check if the fiat convertion you want is supported
         if not self._is_supported_fiat(fiat=fiat_symbol):
-            raise ValueError('The fiat {} is not supported.'.format(fiat_symbol))
+            raise ValueError(f'The fiat {fiat_symbol} is not supported.')
 
         # Get the pair that interest us and return the price in fiat
         for pair in self._pairs:
@@ -182,7 +182,7 @@ class CryptoToFiatConverter(object):
         """
         # Check if the fiat convertion you want is supported
         if not self._is_supported_fiat(fiat=fiat_symbol):
-            raise ValueError('The fiat {} is not supported.'.format(fiat_symbol))
+            raise ValueError(f'The fiat {fiat_symbol} is not supported.')
 
         # No need to convert if both crypto and fiat are the same
         if crypto_symbol == fiat_symbol:
@@ -192,6 +192,7 @@ class CryptoToFiatConverter(object):
             # return 0 for unsupported stake currencies (fiat-convert should not break the bot)
             logger.warning("unsupported crypto-symbol %s - returning 0.0", crypto_symbol)
             return 0.0
+
         try:
             return float(
                 self._coinmarketcap.ticker(

freqtrade/freqtradebot.py

@@ -76,17 +76,14 @@ class FreqtradeBot(object):
         else:
             self.state = State.STOPPED
 
-    def clean(self) -> bool:
+    def cleanup(self) -> None:
         """
-        Cleanup the application state und finish all pending tasks
+        Cleanup pending resources on an already stopped bot
         :return: None
         """
-        self.rpc.send_msg('*Status:* `Stopping trader...`')
-        logger.info('Stopping trader and cleaning up modules...')
-        self.state = State.STOPPED
+        logger.info('Cleaning up modules ...')
         self.rpc.cleanup()
         persistence.cleanup()
-        return True
 
     def worker(self, old_state: State = None) -> State:
         """
@@ -97,7 +94,7 @@ class FreqtradeBot(object):
         # Log state transition
         state = self.state
         if state != old_state:
-            self.rpc.send_msg('*Status:* `{}`'.format(state.name.lower()))
+            self.rpc.send_msg(f'*Status:* `{state.name.lower()}`')
             logger.info('Changing state to: %s', state.name)
 
         if state == State.STOPPED:
@@ -171,12 +168,10 @@ class FreqtradeBot(object):
             logger.warning('%s, retrying in 30 seconds...', error)
             time.sleep(constants.RETRY_TIMEOUT)
         except OperationalException:
+            tb = traceback.format_exc()
+            hint = 'Issue `/start` if you think it is safe to restart.'
             self.rpc.send_msg(
-                '*Status:* OperationalException:\n```\n{traceback}```{hint}'
-                .format(
-                    traceback=traceback.format_exc(),
-                    hint='Issue `/start` if you think it is safe to restart.'
-                )
+                f'*Status:* OperationalException:\n```\n{tb}```{hint}'
             )
             logger.exception('OperationalException. Stopping trader ...')
             self.state = State.STOPPED
@@ -275,8 +270,6 @@ class FreqtradeBot(object):
         """
         Checks the implemented trading indicator(s) for a randomly picked pair,
         if one pair triggers the buy_signal a new trade record gets created
-        :param stake_amount: amount of btc to spend
-        :param interval: Ticker interval used for Analyze
         :return: True if a trade object has been created and persisted, False otherwise
         """
         interval = self.analyze.get_ticker_interval()
@@ -284,6 +277,9 @@ class FreqtradeBot(object):
 
         if not stake_amount:
             return False
+        stake_currency = self.config['stake_currency']
+        fiat_currency = self.config['fiat_display_currency']
+        exc_name = exchange.get_name()
 
         logger.info(
             'Checking buy signals to create a new trade with stake_amount: %f ...',
@@ -308,7 +304,8 @@ class FreqtradeBot(object):
                 break
         else:
             return False
-
+        pair_s = pair.replace('_', '/')
+        pair_url = exchange.get_pair_detail_url(pair)
         # Calculate amount
         buy_limit = self.get_target_bid(exchange.get_ticker(pair))
         amount = stake_amount / buy_limit
@@ -317,23 +314,15 @@ class FreqtradeBot(object):
 
         stake_amount_fiat = self.fiat_converter.convert_amount(
             stake_amount,
-            self.config['stake_currency'],
-            self.config['fiat_display_currency']
+            stake_currency,
+            fiat_currency
         )
 
         # Create trade entity and return
         self.rpc.send_msg(
-            '*{}:* Buying [{}]({}) with limit `{:.8f} ({:.6f} {}, {:.3f} {})` '
-            .format(
-                exchange.get_name(),
-                pair.replace('_', '/'),
-                exchange.get_pair_detail_url(pair),
-                buy_limit,
-                stake_amount,
-                self.config['stake_currency'],
-                stake_amount_fiat,
-                self.config['fiat_display_currency']
-            )
+            f"""*{exc_name}:* Buying [{pair_s}]({pair_url}) \
+with limit `{buy_limit:.8f} ({stake_amount:.6f} \
+{stake_currency}, {stake_amount_fiat:.3f} {fiat_currency})`"""
         )
         # Fee is applied twice because we make a LIMIT_BUY and LIMIT_SELL
         fee = exchange.get_fee(symbol=pair, taker_or_maker='maker')
@@ -434,12 +423,12 @@ class FreqtradeBot(object):
                     fee_abs += exectrade['fee']['cost']
 
         if amount != order_amount:
-            logger.warning("amount {} does not match amount {}".format(amount, trade.amount))
+            logger.warning(f"amount {amount} does not match amount {trade.amount}")
             raise OperationalException("Half bought? Amounts don't match")
         real_amount = amount - fee_abs
         if fee_abs != 0:
-            logger.info("Applying fee on amount for {} (from {} to {}) from Trades".format(
-                        trade, order['amount'], real_amount))
+            logger.info(f"""Applying fee on amount for {trade} \
+(from {order_amount} to {real_amount}) from Trades""")
         return real_amount
 
     def handle_trade(self, trade: Trade) -> bool:
@@ -448,7 +437,7 @@ class FreqtradeBot(object):
         :return: True if trade has been sold, False otherwise
         """
         if not trade.is_open:
-            raise ValueError('attempt to handle closed trade: {}'.format(trade))
+            raise ValueError(f'attempt to handle closed trade: {trade}')
 
         logger.debug('Handling %s ...', trade)
         current_rate = exchange.get_ticker(trade.pair)['bid']
@@ -474,6 +463,12 @@ class FreqtradeBot(object):
 
         for trade in Trade.query.filter(Trade.open_order_id.isnot(None)).all():
             try:
+                # FIXME: Somehow the query above returns results
+                # where the open_order_id is in fact None.
+                # This is probably because the record got
+                # updated via /forcesell in a different thread.
+                if not trade.open_order_id:
+                    continue
                 order = exchange.get_order(trade.open_order_id, trade.pair)
             except requests.exceptions.RequestException:
                 logger.info(
@@ -499,16 +494,14 @@ class FreqtradeBot(object):
         """Buy timeout - cancel order
         :return: True if order was fully cancelled
         """
+        pair_s = trade.pair.replace('_', '/')
         exchange.cancel_order(trade.open_order_id, trade.pair)
         if order['remaining'] == order['amount']:
             # if trade is not partially completed, just delete the trade
             Trade.session.delete(trade)
-            # FIX? do we really need to flush, caller of
-            #      check_handle_timedout will flush afterwards
             Trade.session.flush()
             logger.info('Buy order timeout for %s.', trade)
-            self.rpc.send_msg('*Timeout:* Unfilled buy order for {} cancelled'.format(
-                trade.pair.replace('_', '/')))
+            self.rpc.send_msg(f'*Timeout:* Unfilled buy order for {pair_s} cancelled')
             return True
 
         # if trade is partially complete, edit the stake details for the trade
@@ -517,8 +510,7 @@ class FreqtradeBot(object):
         trade.stake_amount = trade.amount * trade.open_rate
         trade.open_order_id = None
         logger.info('Partial buy order timeout for %s.', trade)
-        self.rpc.send_msg('*Timeout:* Remaining buy order for {} cancelled'.format(
-            trade.pair.replace('_', '/')))
+        self.rpc.send_msg(f'*Timeout:* Remaining buy order for {pair_s} cancelled')
         return False
 
     # FIX: 20180110, should cancel_order() be cond. or unconditionally called?
@@ -527,6 +519,7 @@ class FreqtradeBot(object):
         Sell timeout - cancel order and update trade
         :return: True if order was fully cancelled
         """
+        pair_s = trade.pair.replace('_', '/')
         if order['remaining'] == order['amount']:
             # if trade is not partially completed, just cancel the trade
             exchange.cancel_order(trade.open_order_id, trade.pair)
@@ -535,8 +528,7 @@ class FreqtradeBot(object):
             trade.close_date = None
             trade.is_open = True
             trade.open_order_id = None
-            self.rpc.send_msg('*Timeout:* Unfilled sell order for {} cancelled'.format(
-                trade.pair.replace('_', '/')))
+            self.rpc.send_msg(f'*Timeout:* Unfilled sell order for {pair_s} cancelled')
             logger.info('Sell order timeout for %s.', trade)
             return True
 
@@ -550,6 +542,8 @@ class FreqtradeBot(object):
         :param limit: limit rate for the sell order
         :return: None
         """
+        exc = trade.exchange
+        pair = trade.pair
         # Execute sell and update trade record
         order_id = exchange.sell(str(trade.pair), limit, trade.amount)['id']
         trade.open_order_id = order_id
@@ -559,43 +553,31 @@ class FreqtradeBot(object):
         profit_trade = trade.calc_profit(rate=limit)
         current_rate = exchange.get_ticker(trade.pair)['bid']
         profit = trade.calc_profit_percent(limit)
+        pair_url = exchange.get_pair_detail_url(trade.pair)
+        gain = "profit" if fmt_exp_profit > 0 else "loss"
 
-        message = "*{exchange}:* Selling\n" \
-                  "*Current Pair:* [{pair}]({pair_url})\n" \
-                  "*Limit:* `{limit}`\n" \
-                  "*Amount:* `{amount}`\n" \
-                  "*Open Rate:* `{open_rate:.8f}`\n" \
-                  "*Current Rate:* `{current_rate:.8f}`\n" \
-                  "*Profit:* `{profit:.2f}%`" \
-                  "".format(
-                      exchange=trade.exchange,
-                      pair=trade.pair,
-                      pair_url=exchange.get_pair_detail_url(trade.pair),
-                      limit=limit,
-                      open_rate=trade.open_rate,
-                      current_rate=current_rate,
-                      amount=round(trade.amount, 8),
-                      profit=round(profit * 100, 2),
-                  )
+        message = f"*{exc}:* Selling\n" \
+                  f"*Current Pair:* [{pair}]({pair_url})\n" \
+                  f"*Limit:* `{limit}`\n" \
+                  f"*Amount:* `{round(trade.amount, 8)}`\n" \
+                  f"*Open Rate:* `{trade.open_rate:.8f}`\n" \
+                  f"*Current Rate:* `{current_rate:.8f}`\n" \
+                  f"*Profit:* `{round(profit * 100, 2):.2f}%`" \
+                  ""
 
         # For regular case, when the configuration exists
         if 'stake_currency' in self.config and 'fiat_display_currency' in self.config:
+            stake = self.config['stake_currency']
+            fiat = self.config['fiat_display_currency']
             fiat_converter = CryptoToFiatConverter()
             profit_fiat = fiat_converter.convert_amount(
                 profit_trade,
-                self.config['stake_currency'],
-                self.config['fiat_display_currency']
+                stake,
+                fiat
             )
-            message += '` ({gain}: {profit_percent:.2f}%, {profit_coin:.8f} {coin}`' \
-                       '` / {profit_fiat:.3f} {fiat})`' \
-                       ''.format(
-                           gain="profit" if fmt_exp_profit > 0 else "loss",
-                           profit_percent=fmt_exp_profit,
-                           profit_coin=profit_trade,
-                           coin=self.config['stake_currency'],
-                           profit_fiat=profit_fiat,
-                           fiat=self.config['fiat_display_currency'],
-                       )
+            message += f'` ({gain}: {fmt_exp_profit:.2f}%, {profit_trade:.8f} {stake}`' \
+                       f'` / {profit_fiat:.3f} {fiat})`'\
+                       ''
         # Because telegram._forcesell does not have the configuration
         # Ignore the FIAT value and does not show the stake_currency as well
         else:

freqtrade/main.py

@@ -5,12 +5,14 @@ Read the documentation to know what cli arguments you need.
 """
 import logging
 import sys
+from argparse import Namespace
 from typing import List
 
 from freqtrade import OperationalException
 from freqtrade.arguments import Arguments
 from freqtrade.configuration import Configuration
 from freqtrade.freqtradebot import FreqtradeBot
+from freqtrade.state import State
 
 logger = logging.getLogger('freqtrade')
 
@@ -44,6 +46,8 @@ def main(sysargv: List[str]) -> None:
         state = None
         while 1:
             state = freqtrade.worker(old_state=state)
+            if state == State.RELOAD_CONF:
+                freqtrade = reconfigure(freqtrade, args)
 
     except KeyboardInterrupt:
         logger.info('SIGINT received, aborting ...')
@@ -55,10 +59,28 @@ def main(sysargv: List[str]) -> None:
         logger.exception('Fatal exception!')
     finally:
         if freqtrade:
-            freqtrade.clean()
+            freqtrade.rpc.send_msg('*Status:* `Process died ...`')
+            freqtrade.cleanup()
         sys.exit(return_code)
 
 
+def reconfigure(freqtrade: FreqtradeBot, args: Namespace) -> FreqtradeBot:
+    """
+    Cleans up current instance, reloads the configuration and returns the new instance
+    """
+    # Clean up current modules
+    freqtrade.cleanup()
+
+    # Create new instance
+    freqtrade = FreqtradeBot(Configuration(args).get_config())
+    freqtrade.rpc.send_msg(
+        '*Status:* `Config reloaded ...`'.format(
+            freqtrade.state.name.lower()
+        )
+    )
+    return freqtrade
+
+
 def set_loggers() -> None:
     """
     Set the logger level for Third party libs

freqtrade/optimize/__init__.py

@@ -85,7 +85,7 @@ def load_data(datadir: str,
               ticker_interval: str,
               pairs: Optional[List[str]] = None,
               refresh_pairs: Optional[bool] = False,
-              timerange: TimeRange = TimeRange()) -> Dict[str, List]:
+              timerange: TimeRange = TimeRange(None, None, 0, 0)) -> Dict[str, List]:
     """
     Loads ticker history data for the given parameters
     :return: dict
@@ -125,7 +125,7 @@ def make_testdata_path(datadir: str) -> str:
 
 def download_pairs(datadir, pairs: List[str],
                    ticker_interval: str,
-                   timerange: TimeRange = TimeRange()) -> bool:
+                   timerange: TimeRange = TimeRange(None, None, 0, 0)) -> bool:
     """For each pairs passed in parameters, download the ticker intervals"""
     for pair in pairs:
         try:

freqtrade/rpc/rpc.py

@@ -299,6 +299,11 @@ class RPC(object):
 
         return True, '*Status:* `already stopped`'
 
+    def rpc_reload_conf(self) -> str:
+        """ Handler for reload_conf. """
+        self.freqtrade.state = State.RELOAD_CONF
+        return '*Status:* `Reloading config ...`'
+
     # FIX: no test for this!!!!
     def rpc_forcesell(self, trade_id) -> Tuple[bool, Any]:
         """
@@ -354,6 +359,7 @@ class RPC(object):
             return True, 'Invalid argument.'
 
         _exec_forcesell(trade)
+        Trade.session.flush()
         return False, ''
 
     def rpc_performance(self) -> Tuple[bool, Any]:

freqtrade/rpc/telegram.py

@@ -93,6 +93,7 @@ class Telegram(RPC):
             CommandHandler('performance', self._performance),
             CommandHandler('daily', self._daily),
             CommandHandler('count', self._count),
+            CommandHandler('reload_conf', self._reload_conf),
             CommandHandler('help', self._help),
             CommandHandler('version', self._version),
         ]
@@ -300,6 +301,18 @@ class Telegram(RPC):
         (error, msg) = self.rpc_stop()
         self.send_msg(msg, bot=bot)
 
+    @authorized_only
+    def _reload_conf(self, bot: Bot, update: Update) -> None:
+        """
+        Handler for /reload_conf.
+        Triggers a config file reload
+        :param bot: telegram bot
+        :param update: message update
+        :return: None
+        """
+        msg = self.rpc_reload_conf()
+        self.send_msg(msg, bot=bot)
+
     @authorized_only
     def _forcesell(self, bot: Bot, update: Update) -> None:
         """

freqtrade/state.py

@@ -8,7 +8,8 @@ import enum
 
 class State(enum.Enum):
     """
-    Bot running states
+    Bot application states
     """
     RUNNING = 0
     STOPPED = 1
+    RELOAD_CONF = 2

freqtrade/tests/optimize/test_backtesting.py

@@ -340,7 +340,7 @@ def test_tickerdata_to_dataframe(default_conf, mocker) -> None:
 
     backtesting = Backtesting(default_conf)
     data = backtesting.tickerdata_to_dataframe(tickerlist)
-    assert len(data['UNITTEST/BTC']) == 100
+    assert len(data['UNITTEST/BTC']) == 99
 
     # Load Analyze to compare the result between Backtesting function and Analyze are the same
     analyze = Analyze(default_conf)
@@ -364,7 +364,7 @@ def test_get_timeframe(default_conf, mocker) -> None:
     )
     min_date, max_date = backtesting.get_timeframe(data)
     assert min_date.isoformat() == '2017-11-04T23:02:00+00:00'
-    assert max_date.isoformat() == '2017-11-14T22:59:00+00:00'
+    assert max_date.isoformat() == '2017-11-14T22:58:00+00:00'
 
 
 def test_generate_text_table(default_conf, mocker):
@@ -501,7 +501,7 @@ def test_processed(default_conf, mocker) -> None:
 
 def test_backtest_pricecontours(default_conf, fee, mocker) -> None:
     mocker.patch('freqtrade.optimize.backtesting.exchange.get_fee', fee)
-    tests = [['raise', 17], ['lower', 0], ['sine', 17]]
+    tests = [['raise', 17], ['lower', 0], ['sine', 16]]
     for [contour, numres] in tests:
         simple_backtest(default_conf, contour, numres, mocker)
 
@@ -629,10 +629,12 @@ def test_backtest_start_live(default_conf, mocker, caplog):
     args = [
         '--config', 'config.json',
         '--strategy', 'DefaultStrategy',
+        '--datadir', 'freqtrade/tests/testdata',
         'backtesting',
         '--ticker-interval', '1m',
         '--live',
-        '--timerange', '-100'
+        '--timerange', '-100',
+        '--realistic-simulation'
     ]
     args = get_args(args)
     start(args)
@@ -642,13 +644,14 @@ def test_backtest_start_live(default_conf, mocker, caplog):
         'Using ticker_interval: 1m ...',
         'Parameter -l/--live detected ...',
         'Using max_open_trades: 1 ...',
-        'Parameter --timerange detected: -100 ..',
+        'Parameter --timerange detected: -100 ...',
         'Using data folder: freqtrade/tests/testdata ...',
         'Using stake_currency: BTC ...',
         'Using stake_amount: 0.001 ...',
         'Downloading data for all pairs in whitelist ...',
-        'Measuring data from 2017-11-14T19:32:00+00:00 up to 2017-11-14T22:59:00+00:00 (0 days)..'
+        'Measuring data from 2017-11-14T19:31:00+00:00 up to 2017-11-14T22:58:00+00:00 (0 days)..',
+        'Parameter --realistic-simulation detected ...'
     ]
 
     for line in exists:
-        log_has(line, caplog.record_tuples)
+        assert log_has(line, caplog.record_tuples)

freqtrade/tests/rpc/test_rpc_telegram.py

@@ -70,12 +70,12 @@ def test_init(default_conf, mocker, caplog) -> None:
     assert start_polling.call_count == 0
 
     # number of handles registered
-    assert start_polling.dispatcher.add_handler.call_count == 11
+    assert start_polling.dispatcher.add_handler.call_count > 0
     assert start_polling.start_polling.call_count == 1
 
     message_str = "rpc.telegram is listening for following commands: [['status'], ['profit'], " \
                   "['balance'], ['start'], ['stop'], ['forcesell'], ['performance'], ['daily'], " \
-                  "['count'], ['help'], ['version']]"
+                  "['count'], ['reload_conf'], ['help'], ['version']]"
 
     assert log_has(message_str, caplog.record_tuples)
 
@@ -745,6 +745,29 @@ def test_stop_handle_already_stopped(default_conf, update, mocker) -> None:
     assert 'already stopped' in msg_mock.call_args_list[0][0][0]
 
 
+def test_reload_conf_handle(default_conf, update, mocker) -> None:
+    """ Test _reload_conf() method """
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.freqtradebot.exchange.init', MagicMock())
+    msg_mock = MagicMock()
+    mocker.patch.multiple(
+        'freqtrade.rpc.telegram.Telegram',
+        _init=MagicMock(),
+        send_msg=msg_mock
+    )
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    freqtradebot = FreqtradeBot(default_conf)
+    telegram = Telegram(freqtradebot)
+
+    freqtradebot.state = State.RUNNING
+    assert freqtradebot.state == State.RUNNING
+    telegram._reload_conf(bot=MagicMock(), update=update)
+    assert freqtradebot.state == State.RELOAD_CONF
+    assert msg_mock.call_count == 1
+    assert 'Reloading config' in msg_mock.call_args_list[0][0][0]
+
+
 def test_forcesell_handle(default_conf, update, ticker, fee, ticker_sell_up, mocker) -> None:
     """
     Test _forcesell() method

freqtrade/tests/test_analyze.py

@@ -46,7 +46,7 @@ def test_analyze_object() -> None:
 
 def test_dataframe_correct_length(result):
     dataframe = Analyze.parse_ticker_dataframe(result)
-    assert len(result.index) == len(dataframe.index)
+    assert len(result.index) - 1 == len(dataframe.index)    # last partial candle removed
 
 
 def test_dataframe_correct_columns(result):
@@ -188,4 +188,4 @@ def test_tickerdata_to_dataframe(default_conf) -> None:
     tick = load_tickerdata_file(None, 'UNITTEST/BTC', '1m', timerange=timerange)
     tickerlist = {'UNITTEST/BTC': tick}
     data = analyze.tickerdata_to_dataframe(tickerlist)
-    assert len(data['UNITTEST/BTC']) == 100
+    assert len(data['UNITTEST/BTC']) == 99       # partial candle was removed

freqtrade/tests/test_arguments.py

@@ -174,3 +174,19 @@ def test_parse_args_hyperopt_custom() -> None:
     assert call_args.subparser == 'hyperopt'
     assert call_args.spaces == ['buy']
     assert call_args.func is not None
+
+
+def test_testdata_dl_options() -> None:
+    args = [
+        '--pairs-file', 'file_with_pairs',
+        '--export', 'export/folder',
+        '--days', '30',
+        '--exchange', 'binance'
+    ]
+    arguments = Arguments(args, '')
+    arguments.testdata_dl_options()
+    args = arguments.parse_args()
+    assert args.pairs_file == 'file_with_pairs'
+    assert args.export == 'export/folder'
+    assert args.days == 30
+    assert args.exchange == 'binance'

freqtrade/tests/test_configuration.py

@@ -97,7 +97,7 @@ def test_load_config_max_open_trades_zero(default_conf, mocker, caplog) -> None:
     assert log_has('Validating configuration ...', caplog.record_tuples)
 
 
-def test_load_config_file_exception(mocker, caplog) -> None:
+def test_load_config_file_exception(mocker) -> None:
     """
     Test Configuration._load_config_file() method
     """
@@ -107,12 +107,8 @@ def test_load_config_file_exception(mocker, caplog) -> None:
     )
     configuration = Configuration(Namespace())
 
-    with pytest.raises(SystemExit):
+    with pytest.raises(OperationalException, match=r'.*Config file "somefile" not found!*'):
         configuration._load_config_file('somefile')
-    assert log_has(
-        'Config file "somefile" not found. Please create your config file',
-        caplog.record_tuples
-    )
 
 
 def test_load_config(default_conf, mocker) -> None:

freqtrade/tests/test_fiat_convert.py

@@ -9,7 +9,7 @@ import pytest
 from requests.exceptions import RequestException
 
 from freqtrade.fiat_convert import CryptoFiat, CryptoToFiatConverter
-from freqtrade.tests.conftest import patch_coinmarketcap
+from freqtrade.tests.conftest import log_has, patch_coinmarketcap
 
 
 def test_pair_convertion_object():
@@ -90,6 +90,13 @@ def test_fiat_convert_find_price(mocker):
     assert fiat_convert.get_price(crypto_symbol='BTC', fiat_symbol='EUR') == 13000.2
 
 
+def test_fiat_convert_unsupported_crypto(mocker, caplog):
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter._cryptomap', return_value=[])
+    fiat_convert = CryptoToFiatConverter()
+    assert fiat_convert._find_price(crypto_symbol='CRYPTO_123', fiat_symbol='EUR') == 0.0
+    assert log_has('unsupported crypto-symbol CRYPTO_123 - returning 0.0', caplog.record_tuples)
+
+
 def test_fiat_convert_get_price(mocker):
     api_mock = MagicMock(return_value={
         'price_usd': 28000.0,
@@ -161,7 +168,8 @@ def test_fiat_init_network_exception(mocker):
     fiat_convert._cryptomap = {}
     fiat_convert._load_cryptomap()
 
-    assert len(fiat_convert._cryptomap) == 0
+    length_cryptomap = len(fiat_convert._cryptomap)
+    assert length_cryptomap == 0
 
 
 def test_fiat_convert_without_network():
@@ -175,3 +183,22 @@ def test_fiat_convert_without_network():
     assert fiat_convert._coinmarketcap is None
     assert fiat_convert._find_price(crypto_symbol='BTC', fiat_symbol='USD') == 0.0
     CryptoToFiatConverter._coinmarketcap = cmc_temp
+
+
+def test_convert_amount(mocker):
+    mocker.patch('freqtrade.fiat_convert.CryptoToFiatConverter.get_price', return_value=12345.0)
+
+    fiat_convert = CryptoToFiatConverter()
+    result = fiat_convert.convert_amount(
+        crypto_amount=1.23,
+        crypto_symbol="BTC",
+        fiat_symbol="USD"
+    )
+    assert result == 15184.35
+
+    result = fiat_convert.convert_amount(
+        crypto_amount=1.23,
+        crypto_symbol="BTC",
+        fiat_symbol="BTC"
+    )
+    assert result == 1.23

freqtrade/tests/test_freqtradebot.py

@@ -68,7 +68,7 @@ def test_freqtradebot_object() -> None:
     Test the FreqtradeBot object has the mandatory public methods
     """
     assert hasattr(FreqtradeBot, 'worker')
-    assert hasattr(FreqtradeBot, 'clean')
+    assert hasattr(FreqtradeBot, 'cleanup')
     assert hasattr(FreqtradeBot, 'create_trade')
     assert hasattr(FreqtradeBot, 'get_target_bid')
     assert hasattr(FreqtradeBot, 'process_maybe_execute_buy')
@@ -93,7 +93,7 @@ def test_freqtradebot(mocker, default_conf) -> None:
     assert freqtrade.state is State.STOPPED
 
 
-def test_clean(mocker, default_conf, caplog) -> None:
+def test_cleanup(mocker, default_conf, caplog) -> None:
     """
     Test clean() method
     """
@@ -101,11 +101,8 @@ def test_clean(mocker, default_conf, caplog) -> None:
     mocker.patch('freqtrade.persistence.cleanup', mock_cleanup)
 
     freqtrade = get_patched_freqtradebot(mocker, default_conf)
-    assert freqtrade.state == State.RUNNING
-
-    assert freqtrade.clean()
-    assert freqtrade.state == State.STOPPED
-    assert log_has('Stopping trader and cleaning up modules...', caplog.record_tuples)
+    freqtrade.cleanup()
+    assert log_has('Cleaning up modules ...', caplog.record_tuples)
     assert mock_cleanup.call_count == 1
 
 
@@ -682,8 +679,10 @@ def test_process_maybe_execute_sell(mocker, default_conf, limit_buy_order, caplo
     trade.open_fee = 0.001
     assert not freqtrade.process_maybe_execute_sell(trade)
     # Test amount not modified by fee-logic
-    assert not log_has('Applying fee to amount for Trade {} from 90.99181073 to 90.81'.format(
-                       trade), caplog.record_tuples)
+    assert not log_has(
+        'Applying fee to amount for Trade {} from 90.99181073 to 90.81'.format(trade),
+        caplog.record_tuples
+    )
 
     mocker.patch('freqtrade.freqtradebot.FreqtradeBot.get_real_amount', return_value=90.81)
     # test amount modified by fee-logic
@@ -694,6 +693,38 @@ def test_process_maybe_execute_sell(mocker, default_conf, limit_buy_order, caplo
     # Assert we call handle_trade() if trade is feasible for execution
     assert freqtrade.process_maybe_execute_sell(trade)
 
+    regexp = re.compile('Found open order for.*')
+    assert filter(regexp.match, caplog.record_tuples)
+
+
+def test_process_maybe_execute_sell_exception(mocker, default_conf,
+                                              limit_buy_order, caplog) -> None:
+    """
+    Test the exceptions in process_maybe_execute_sell()
+    """
+    freqtrade = get_patched_freqtradebot(mocker, default_conf)
+    mocker.patch('freqtrade.freqtradebot.exchange.get_order', return_value=limit_buy_order)
+
+    trade = MagicMock()
+    trade.open_order_id = '123'
+    trade.open_fee = 0.001
+
+    # Test raise of OperationalException exception
+    mocker.patch(
+        'freqtrade.freqtradebot.FreqtradeBot.get_real_amount',
+        side_effect=OperationalException()
+    )
+    freqtrade.process_maybe_execute_sell(trade)
+    assert log_has('could not update trade amount: ', caplog.record_tuples)
+
+    # Test raise of DependencyException exception
+    mocker.patch(
+        'freqtrade.freqtradebot.FreqtradeBot.get_real_amount',
+        side_effect=DependencyException()
+    )
+    freqtrade.process_maybe_execute_sell(trade)
+    assert log_has('Unable to sell trade: ', caplog.record_tuples)
+
 
 def test_handle_trade(default_conf, limit_buy_order, limit_sell_order, fee, mocker) -> None:
     """
@@ -1468,7 +1499,7 @@ def test_get_real_amount_no_trade(default_conf, buy_order_fee, caplog, mocker):
                    caplog.record_tuples)
 
 
-def test_get_real_amount_stake(default_conf, trades_for_order, buy_order_fee, caplog, mocker):
+def test_get_real_amount_stake(default_conf, trades_for_order, buy_order_fee, mocker):
     """
     Test get_real_amount - fees in Stake currency
     """
@@ -1620,3 +1651,28 @@ def test_get_real_amount_invalid(default_conf, trades_for_order, buy_order_fee,
     freqtrade = FreqtradeBot(default_conf)
     # Amount does not change
     assert freqtrade.get_real_amount(trade, buy_order_fee) == amount
+
+
+def test_get_real_amount_open_trade(default_conf, mocker):
+    """
+    Test get_real_amount condition trade.fee_open == 0 or order['status'] == 'open'
+    """
+    patch_get_signal(mocker)
+    patch_RPCManager(mocker)
+    patch_coinmarketcap(mocker)
+    mocker.patch('freqtrade.exchange.validate_pairs', MagicMock(return_value=True))
+    amount = 12345
+    trade = Trade(
+        pair='LTC/ETH',
+        amount=amount,
+        exchange='binance',
+        open_rate=0.245441,
+        open_order_id="123456"
+    )
+    order = {
+        'id': 'mocked_order',
+        'amount': amount,
+        'status': 'open',
+    }
+    freqtrade = FreqtradeBot(default_conf)
+    assert freqtrade.get_real_amount(trade, order) == amount

freqtrade/tests/test_main.py

@@ -3,11 +3,16 @@ Unit test file for main.py
 """
 
 import logging
+from copy import deepcopy
 from unittest.mock import MagicMock
 
 import pytest
 
-from freqtrade.main import main, set_loggers
+from freqtrade import OperationalException
+from freqtrade.arguments import Arguments
+from freqtrade.freqtradebot import FreqtradeBot
+from freqtrade.main import main, set_loggers, reconfigure
+from freqtrade.state import State
 from freqtrade.tests.conftest import log_has
 
 
@@ -60,7 +65,7 @@ def test_set_loggers() -> None:
     assert value2 is logging.INFO
 
 
-def test_main(mocker, caplog) -> None:
+def test_main_fatal_exception(mocker, default_conf, caplog) -> None:
     """
     Test main() function
     In this test we are skipping the while True loop by throwing an exception.
@@ -68,26 +73,140 @@ def test_main(mocker, caplog) -> None:
     mocker.patch.multiple(
         'freqtrade.freqtradebot.FreqtradeBot',
         _init_modules=MagicMock(),
-        worker=MagicMock(
-            side_effect=KeyboardInterrupt
-        ),
-        clean=MagicMock(),
+        worker=MagicMock(side_effect=Exception),
+        cleanup=MagicMock(),
     )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
     args = ['-c', 'config.json.example']
 
     # Test Main + the KeyboardInterrupt exception
-    with pytest.raises(SystemExit) as pytest_wrapped_e:
-        main(args)
-        log_has('Starting freqtrade', caplog.record_tuples)
-        log_has('Got SIGINT, aborting ...', caplog.record_tuples)
-        assert pytest_wrapped_e.type == SystemExit
-        assert pytest_wrapped_e.value.code == 42
-
-    # Test the BaseException case
-    mocker.patch(
-        'freqtrade.freqtradebot.FreqtradeBot.worker',
-        MagicMock(side_effect=BaseException)
-    )
     with pytest.raises(SystemExit):
         main(args)
-        log_has('Got fatal exception!', caplog.record_tuples)
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+    assert log_has('Fatal exception!', caplog.record_tuples)
+
+
+def test_main_keyboard_interrupt(mocker, default_conf, caplog) -> None:
+    """
+    Test main() function
+    In this test we are skipping the while True loop by throwing an exception.
+    """
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(side_effect=KeyboardInterrupt),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    args = ['-c', 'config.json.example']
+
+    # Test Main + the KeyboardInterrupt exception
+    with pytest.raises(SystemExit):
+        main(args)
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+    assert log_has('SIGINT received, aborting ...', caplog.record_tuples)
+
+
+def test_main_operational_exception(mocker, default_conf, caplog) -> None:
+    """
+    Test main() function
+    In this test we are skipping the while True loop by throwing an exception.
+    """
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(side_effect=OperationalException('Oh snap!')),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    args = ['-c', 'config.json.example']
+
+    # Test Main + the KeyboardInterrupt exception
+    with pytest.raises(SystemExit):
+        main(args)
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+    assert log_has('Oh snap!', caplog.record_tuples)
+
+
+def test_main_reload_conf(mocker, default_conf, caplog) -> None:
+    """
+    Test main() function
+    In this test we are skipping the while True loop by throwing an exception.
+    """
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(return_value=State.RELOAD_CONF),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    # Raise exception as side effect to avoid endless loop
+    reconfigure_mock = mocker.patch(
+        'freqtrade.main.reconfigure', MagicMock(side_effect=Exception)
+    )
+
+    with pytest.raises(SystemExit):
+        main(['-c', 'config.json.example'])
+
+    assert reconfigure_mock.call_count == 1
+    assert log_has('Using config: config.json.example ...', caplog.record_tuples)
+
+
+def test_reconfigure(mocker, default_conf) -> None:
+    """ Test recreate() function """
+    mocker.patch.multiple(
+        'freqtrade.freqtradebot.FreqtradeBot',
+        _init_modules=MagicMock(),
+        worker=MagicMock(side_effect=OperationalException('Oh snap!')),
+        cleanup=MagicMock(),
+    )
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: default_conf
+    )
+    mocker.patch('freqtrade.freqtradebot.CryptoToFiatConverter', MagicMock())
+    mocker.patch('freqtrade.freqtradebot.RPCManager', MagicMock())
+
+    freqtrade = FreqtradeBot(default_conf)
+
+    # Renew mock to return modified data
+    conf = deepcopy(default_conf)
+    conf['stake_amount'] += 1
+    mocker.patch(
+        'freqtrade.configuration.Configuration._load_config_file',
+        lambda *args, **kwargs: conf
+    )
+
+    # reconfigure should return a new instance
+    freqtrade2 = reconfigure(
+        freqtrade,
+        Arguments(['-c', 'config.json.example'], '').get_parsed_arg()
+    )
+
+    # Verify we have a new instance with the new config
+    assert freqtrade is not freqtrade2
+    assert freqtrade.config['stake_amount'] + 1 == freqtrade2.config['stake_amount']

freqtrade/tests/test_misc.py

@@ -39,7 +39,7 @@ def test_datesarray_to_datetimearray(ticker_history):
     assert dates[0].minute == 50
 
     date_len = len(dates)
-    assert date_len == 3
+    assert date_len == 2
 
 
 def test_common_datearray(default_conf) -> None: