10 files changed, 204 insertions, 87 deletions

diff --git a/ccxt_wrapper.py b/ccxt_wrapper.py
index bedf84b..366586c 100644
--- a/ccxt_wrapper.py
+++ b/ccxt_wrapper.py
@@ -47,6 +47,8 @@ class poloniexE(poloniex):
         self.session._parent = self
 
         def request_wrap(self, *args, **kwargs):
+            kwargs["headers"]["X-market-id"] = str(self._parent._market.market_id)
+            kwargs["headers"]["X-user-id"] = str(self._parent._market.user_id)
             try:
                 r = self.origin_request(*args, **kwargs)
                 self._parent._market.report.log_http_request(args[0],
diff --git a/main.py b/main.py
index 6383ed1..2cfb01d 100644
--- a/main.py
+++ b/main.py
@@ -1,4 +1,3 @@
-from datetime import datetime
 import configargparse
 import psycopg2
 import os
@@ -170,13 +169,21 @@ def main(argv):
         import threading
         market.Portfolio.start_worker()
 
+        threads = []
         def process_(*args):
-            threading.Thread(target=process, args=args).start()
+            thread = threading.Thread(target=process, args=args)
+            thread.start()
+            threads.append(thread)
     else:
         process_ = process
 
     for market_id, market_config, user_id in fetch_markets(pg_config, args.user):
         process_(market_config, market_id, user_id, args, pg_config)
 
+    if args.parallel:
+        for thread in threads:
+            thread.join()
+        market.Portfolio.stop_worker()
+
 if __name__ == '__main__': # pragma: no cover
     main(sys.argv[1:])
diff --git a/market.py b/market.py
index e16641c..7a37cf6 100644
--- a/market.py
+++ b/market.py
@@ -5,6 +5,7 @@ import psycopg2
 from store import *
 from cachetools.func import ttl_cache
 from datetime import datetime
+import datetime
 from retry import retry
 import portfolio
 
@@ -28,7 +29,7 @@ class Market:
         for key in ["user_id", "market_id", "pg_config"]:
             setattr(self, key, kwargs.get(key, None))
 
-        self.report.log_market(self.args, self.user_id, self.market_id)
+        self.report.log_market(self.args)
 
     @classmethod
     def from_config(cls, config, args, **kwargs):
@@ -40,7 +41,7 @@ class Market:
 
     def store_report(self):
         self.report.merge(Portfolio.report)
-        date = datetime.now()
+        date = datetime.datetime.now()
         if self.args.report_path is not None:
             self.store_file_report(date)
         if self.pg_config is not None and self.args.report_db:
diff --git a/portfolio.py b/portfolio.py
index 535aaa8..146ee79 100644
--- a/portfolio.py
+++ b/portfolio.py
@@ -1,4 +1,4 @@
-from datetime import datetime
+import datetime
 from retry import retry
 from decimal import Decimal as D, ROUND_DOWN
 from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder, OrderNotCached, OrderNotFound, RequestTimeout, InvalidNonce
@@ -492,7 +492,7 @@ class Order:
             self.market.report.log_debug_action(action)
             self.results.append({"debug": True, "id": -1})
         else:
-            self.start_date = datetime.now()
+            self.start_date = datetime.datetime.now()
             try:
                 self.results.append(self.market.ccxt.create_order(symbol, 'limit', self.action, amount, price=self.rate, account=self.account))
             except InvalidOrder:
@@ -677,7 +677,7 @@ class Mouvement:
         self.action = hash_.get("type")
         self.fee_rate = D(hash_.get("fee", -1))
         try:
-            self.date = datetime.strptime(hash_.get("date", ""), '%Y-%m-%d %H:%M:%S')
+            self.date = datetime.datetime.strptime(hash_.get("date", ""), '%Y-%m-%d %H:%M:%S')
         except ValueError:
             self.date = None
         self.rate = D(hash_.get("rate", 0))
diff --git a/store.py b/store.py
index 67e8a8f..467dd4b 100644
--- a/store.py
+++ b/store.py
@@ -3,7 +3,7 @@ import requests
 import portfolio
 import simplejson as json
 from decimal import Decimal as D, ROUND_DOWN
-from datetime import date, datetime, timedelta
+import datetime
 import inspect
 from json import JSONDecodeError
 from simplejson.errors import JSONDecodeError as SimpleJSONDecodeError
@@ -11,13 +11,16 @@ from simplejson.errors import JSONDecodeError as SimpleJSONDecodeError
 __all__ = ["Portfolio", "BalanceStore", "ReportStore", "TradeStore"]
 
 class ReportStore:
-    def __init__(self, market, verbose_print=True):
+    def __init__(self, market, verbose_print=True, no_http_dup=False):
         self.market = market
         self.verbose_print = verbose_print
 
         self.print_logs = []
         self.logs = []
 
+        self.no_http_dup = no_http_dup
+        self.last_http = None
+
     def merge(self, other_report):
         self.logs += other_report.logs
         self.logs.sort(key=lambda x: x["date"])
@@ -26,19 +29,26 @@ class ReportStore:
         self.print_logs.sort(key=lambda x: x[0])
 
     def print_log(self, message):
-        now = datetime.now()
+        now = datetime.datetime.now()
         message = "{:%Y-%m-%d %H:%M:%S}: {}".format(now, str(message))
         self.print_logs.append([now, message])
         if self.verbose_print:
             print(message)
 
     def add_log(self, hash_):
-        hash_["date"] = datetime.now()
+        hash_["date"] = datetime.datetime.now()
+        if self.market is not None:
+            hash_["user_id"] = self.market.user_id
+            hash_["market_id"] = self.market.market_id
+        else:
+            hash_["user_id"] = None
+            hash_["market_id"] = None
         self.logs.append(hash_)
+        return hash_
 
     @staticmethod
     def default_json_serial(obj):
-        if isinstance(obj, (datetime, date)):
+        if isinstance(obj, (datetime.datetime, datetime.date)):
             return obj.isoformat()
         return str(obj)
 
@@ -188,7 +198,12 @@ class ReportStore:
                 "error": response.__class__.__name__,
                 "error_message": str(response),
                 })
-        else:
+            self.last_http = None
+        elif self.no_http_dup and \
+                self.last_http is not None and \
+                self.last_http["url"] == url and \
+                self.last_http["method"] == method and \
+                self.last_http["response"] == response.text:
             self.add_log({
                 "type": "http_request",
                 "method": method,
@@ -196,7 +211,19 @@ class ReportStore:
                 "body": body,
                 "headers": headers,
                 "status": response.status_code,
-                "response": response.text
+                "response": None,
+                "response_same_as": self.last_http["date"]
+                })
+        else:
+            self.last_http = self.add_log({
+                "type": "http_request",
+                "method": method,
+                "url": url,
+                "body": body,
+                "headers": headers,
+                "status": response.status_code,
+                "response": response.text,
+                "response_same_as": None,
                 })
 
     def log_error(self, action, message=None, exception=None):
@@ -222,13 +249,11 @@ class ReportStore:
             "action": action,
             })
 
-    def log_market(self, args, user_id, market_id):
+    def log_market(self, args):
         self.add_log({
             "type": "market",
             "commit": "$Format:%H$",
             "args": vars(args),
-            "user_id": user_id,
-            "market_id": market_id,
             })
 
 class BalanceStore:
@@ -382,7 +407,7 @@ class Portfolio:
     data = LockedVar(None)
     liquidities = LockedVar({})
     last_date = LockedVar(None)
-    report = LockedVar(ReportStore(None))
+    report = LockedVar(ReportStore(None, no_http_dup=True))
     worker = None
     worker_started = False
     worker_notify = None
@@ -418,11 +443,17 @@ class Portfolio:
             raise RuntimeError("This method needs to be ran with the worker")
         while cls.worker_started:
             cls.worker_notify.wait()
-            cls.worker_notify.clear()
-            cls.report.print_log("Fetching cryptoportfolio")
-            cls.get_cryptoportfolio(refetch=True)
-            cls.callback.set()
-            time.sleep(poll)
+            if cls.worker_started:
+                cls.worker_notify.clear()
+                cls.report.print_log("Fetching cryptoportfolio")
+                cls.get_cryptoportfolio(refetch=True)
+                cls.callback.set()
+                time.sleep(poll)
+
+    @classmethod
+    def stop_worker(cls):
+        cls.worker_started = False
+        cls.worker_notify.set()
 
     @classmethod
     def notify_and_wait(cls):
@@ -433,7 +464,7 @@ class Portfolio:
     @classmethod
     def wait_for_recent(cls, delta=4, poll=30):
         cls.get_cryptoportfolio()
-        while cls.last_date.get() is None or datetime.now() - cls.last_date.get() > timedelta(delta):
+        while cls.last_date.get() is None or datetime.datetime.now() - cls.last_date.get() > datetime.timedelta(delta):
             if cls.worker is None:
                 time.sleep(poll)
                 cls.report.print_log("Attempt to fetch up-to-date cryptoportfolio")
@@ -490,7 +521,7 @@ class Portfolio:
             weights_hash = portfolio_hash["weights"]
             weights = {}
             for i in range(len(weights_hash["_row"])):
-                date = datetime.strptime(weights_hash["_row"][i], "%Y-%m-%d")
+                date = datetime.datetime.strptime(weights_hash["_row"][i], "%Y-%m-%d")
                 weights[date] = dict(filter(
                         filter_weights,
                         map(clean_weights(i), weights_hash.items())))
@@ -504,8 +535,7 @@ class Portfolio:
             "high":   high_liquidity,
             })
         cls.last_date.set(max(
-            max(medium_liquidity.keys(), default=datetime(1, 1, 1)),
-            max(high_liquidity.keys(), default=datetime(1, 1, 1))
+            max(medium_liquidity.keys(), default=datetime.datetime(1, 1, 1)),
+            max(high_liquidity.keys(), default=datetime.datetime(1, 1, 1))
             ))
 
-
diff --git a/tests/test_ccxt_wrapper.py b/tests/test_ccxt_wrapper.py
index d32469a..597fe5c 100644
--- a/tests/test_ccxt_wrapper.py
+++ b/tests/test_ccxt_wrapper.py
@@ -22,11 +22,13 @@ class poloniexETest(unittest.TestCase):
             ccxt = market.ccxt.poloniexE()
             ccxt._market = mock.Mock
             ccxt._market.report = mock.Mock()
+            ccxt._market.market_id = 3
+            ccxt._market.user_id = 3
 
             ccxt.session.request("GET", "URL", data="data",
-                    headers="headers")
+                    headers={})
             ccxt._market.report.log_http_request.assert_called_with('GET', 'URL', 'data',
-                    'headers', 'response')
+                    {'X-market-id': '3', 'X-user-id': '3'}, 'response')
 
         with self.subTest("Raising"),\
                 mock.patch("market.ccxt.poloniexE.session") as session:
@@ -35,12 +37,14 @@ class poloniexETest(unittest.TestCase):
             ccxt = market.ccxt.poloniexE()
             ccxt._market = mock.Mock
             ccxt._market.report = mock.Mock()
+            ccxt._market.market_id = 3
+            ccxt._market.user_id = 3
 
             with self.assertRaises(market.ccxt.RequestException, msg="Boo") as cm:
                 ccxt.session.request("GET", "URL", data="data",
-                        headers="headers")
+                        headers={})
             ccxt._market.report.log_http_request.assert_called_with('GET', 'URL', 'data',
-                    'headers', cm.exception)
+                    {'X-market-id': '3', 'X-user-id': '3'}, cm.exception)
 
 
     def test_nanoseconds(self):
diff --git a/tests/test_main.py b/tests/test_main.py
index 6396c07..e3a5677 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -179,7 +179,8 @@ class MainTest(WebMockTestCase):
                     mock.patch("main.parse_config") as parse_config,\
                     mock.patch("main.fetch_markets") as fetch_markets,\
                     mock.patch("main.process") as process,\
-                    mock.patch("store.Portfolio.start_worker") as start:
+                    mock.patch("store.Portfolio.start_worker") as start,\
+                    mock.patch("store.Portfolio.stop_worker") as stop:
 
                 args_mock = mock.Mock()
                 args_mock.parallel = True
@@ -196,6 +197,7 @@ class MainTest(WebMockTestCase):
                 parse_config.assert_called_with(args_mock)
                 fetch_markets.assert_called_with("pg_config", "user")
 
+                stop.assert_called_once_with()
                 start.assert_called_once_with()
                 self.assertEqual(2, process.call_count)
                 process.assert_has_calls([
diff --git a/tests/test_market.py b/tests/test_market.py
index 82eeea8..14b23b5 100644
--- a/tests/test_market.py
+++ b/tests/test_market.py
@@ -548,7 +548,7 @@ class MarketTest(WebMockTestCase):
                 mock.patch.object(m, "report") as report,\
                 mock.patch.object(m, "store_file_report") as file_report,\
                 mock.patch.object(m, "store_database_report") as db_report,\
-                mock.patch.object(market, "datetime") as time_mock:
+                mock.patch.object(market.datetime, "datetime") as time_mock:
 
             time_mock.now.return_value = datetime.datetime(2018, 2, 25)
 
@@ -564,7 +564,7 @@ class MarketTest(WebMockTestCase):
                 mock.patch.object(m, "report") as report,\
                 mock.patch.object(m, "store_file_report") as file_report,\
                 mock.patch.object(m, "store_database_report") as db_report,\
-                mock.patch.object(market, "datetime") as time_mock:
+                mock.patch.object(market.datetime, "datetime") as time_mock:
 
             time_mock.now.return_value = datetime.datetime(2018, 2, 25)
 
@@ -580,7 +580,7 @@ class MarketTest(WebMockTestCase):
                 mock.patch.object(m, "report") as report,\
                 mock.patch.object(m, "store_file_report") as file_report,\
                 mock.patch.object(m, "store_database_report") as db_report,\
-                mock.patch.object(market, "datetime") as time_mock:
+                mock.patch.object(market.datetime, "datetime") as time_mock:
 
             time_mock.now.return_value = datetime.datetime(2018, 2, 25)
 
@@ -597,7 +597,7 @@ class MarketTest(WebMockTestCase):
                 mock.patch.object(m, "report") as report,\
                 mock.patch.object(m, "store_file_report") as file_report,\
                 mock.patch.object(m, "store_database_report") as db_report,\
-                mock.patch.object(market, "datetime") as time_mock:
+                mock.patch.object(market.datetime, "datetime") as time_mock:
 
             time_mock.now.return_value = datetime.datetime(2018, 2, 25)
 
diff --git a/tests/test_portfolio.py b/tests/test_portfolio.py
index a1b95bf..98048ac 100644
--- a/tests/test_portfolio.py
+++ b/tests/test_portfolio.py
@@ -1742,7 +1742,7 @@ class MouvementTest(WebMockTestCase):
         self.assertEqual(42, mouvement.id)
         self.assertEqual("buy", mouvement.action)
         self.assertEqual(D("0.0015"), mouvement.fee_rate)
-        self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), mouvement.date)
+        self.assertEqual(portfolio.datetime.datetime(2017, 12, 30, 12, 0, 12), mouvement.date)
         self.assertEqual(D("0.1"), mouvement.rate)
         self.assertEqual(portfolio.Amount("ETH", "10"), mouvement.total)
         self.assertEqual(portfolio.Amount("BTC", "1"), mouvement.total_in_base)
@@ -1780,7 +1780,7 @@ class MouvementTest(WebMockTestCase):
         as_json = mouvement.as_json()
 
         self.assertEqual(D("0.0015"), as_json["fee_rate"])
-        self.assertEqual(portfolio.datetime(2017, 12, 30, 12, 0, 12), as_json["date"])
+        self.assertEqual(portfolio.datetime.datetime(2017, 12, 30, 12, 0, 12), as_json["date"])
         self.assertEqual("buy", as_json["action"])
         self.assertEqual(D("10"), as_json["total"])
         self.assertEqual(D("1"), as_json["total_in_base"])
diff --git a/tests/test_store.py b/tests/test_store.py
index c0b1fb9..2b51719 100644
--- a/tests/test_store.py
+++ b/tests/test_store.py
@@ -444,10 +444,20 @@ class BalanceStoreTest(WebMockTestCase):
 @unittest.skipUnless("unit" in limits, "Unit skipped")
 class ReportStoreTest(WebMockTestCase):
     def test_add_log(self):
-        report_store = market.ReportStore(self.m)
-        report_store.add_log({"foo": "bar"})
+        with self.subTest(market=self.m):
+            self.m.user_id = 1
+            self.m.market_id = 3
+            report_store = market.ReportStore(self.m)
+            result = report_store.add_log({"foo": "bar"})
+
+            self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": 1, "market_id": 3}, result)
+            self.assertEqual(result, report_store.logs[0])
+
+        with self.subTest(market=None):
+            report_store = market.ReportStore(None)
+            result = report_store.add_log({"foo": "bar"})
 
-        self.assertEqual({"foo": "bar", "date": mock.ANY}, report_store.logs[0])
+            self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": None, "market_id": None}, result)
 
     def test_set_verbose(self):
         report_store = market.ReportStore(self.m)
@@ -460,6 +470,8 @@ class ReportStoreTest(WebMockTestCase):
             self.assertFalse(report_store.verbose_print)
 
     def test_merge(self):
+        self.m.user_id = 1
+        self.m.market_id = 3
         report_store1 = market.ReportStore(self.m, verbose_print=False)
         report_store2 = market.ReportStore(None, verbose_print=False)
 
@@ -478,7 +490,7 @@ class ReportStoreTest(WebMockTestCase):
         with self.subTest(verbose=True),\
                 mock.patch.object(store, "datetime") as time_mock,\
                 mock.patch('sys.stdout', new_callable=StringIO) as stdout_mock:
-            time_mock.now.return_value = datetime.datetime(2018, 2, 25, 2, 20, 10)
+            time_mock.datetime.now.return_value = datetime.datetime(2018, 2, 25, 2, 20, 10)
             report_store.set_verbose(True)
             report_store.print_log("Coucou")
             report_store.print_log(portfolio.Amount("BTC", 1))
@@ -495,7 +507,7 @@ class ReportStoreTest(WebMockTestCase):
         report_store = market.ReportStore(self.m)
 
         self.assertEqual("2018-02-24T00:00:00",
-                report_store.default_json_serial(portfolio.datetime(2018, 2, 24)))
+                report_store.default_json_serial(portfolio.datetime.datetime(2018, 2, 24)))
         self.assertEqual("1.00000000 BTC",
                 report_store.default_json_serial(portfolio.Amount("BTC", 1)))
 
@@ -503,7 +515,7 @@ class ReportStoreTest(WebMockTestCase):
         report_store = market.ReportStore(self.m)
         report_store.logs.append({"foo": "bar"})
         self.assertEqual('[\n  {\n    "foo": "bar"\n  }\n]', report_store.to_json())
-        report_store.logs.append({"date": portfolio.datetime(2018, 2, 24)})
+        report_store.logs.append({"date": portfolio.datetime.datetime(2018, 2, 24)})
         self.assertEqual('[\n  {\n    "foo": "bar"\n  },\n  {\n    "date": "2018-02-24T00:00:00"\n  }\n]', report_store.to_json())
         report_store.logs.append({"amount": portfolio.Amount("BTC", 1)})
         self.assertEqual('[\n  {\n    "foo": "bar"\n  },\n  {\n    "date": "2018-02-24T00:00:00"\n  },\n  {\n    "amount": "1.00000000 BTC"\n  }\n]', report_store.to_json())
@@ -817,53 +829,99 @@ class ReportStoreTest(WebMockTestCase):
                 }
             })
 
-    @mock.patch.object(market.ReportStore, "print_log")
-    @mock.patch.object(market.ReportStore, "add_log")
-    def test_log_http_request(self, add_log, print_log):
-        report_store = market.ReportStore(self.m)
-        response = mock.Mock()
-        response.status_code = 200
-        response.text = "Hey"
+    def test_log_http_request(self):
+        with mock.patch.object(market.ReportStore, "add_log") as add_log:
+            report_store = market.ReportStore(self.m)
+            response = mock.Mock()
+            response.status_code = 200
+            response.text = "Hey"
 
-        report_store.log_http_request("method", "url", "body",
-                "headers", response)
-        print_log.assert_not_called()
-        add_log.assert_called_once_with({
-            'type': 'http_request',
-            'method': 'method',
-            'url': 'url',
-            'body': 'body',
-            'headers': 'headers',
-            'status': 200,
-            'response': 'Hey'
-            })
+            report_store.log_http_request("method", "url", "body",
+                    "headers", response)
+            add_log.assert_called_once_with({
+                'type': 'http_request',
+                'method': 'method',
+                'url': 'url',
+                'body': 'body',
+                'headers': 'headers',
+                'status': 200,
+                'response': 'Hey',
+                'response_same_as': None,
+                })
 
-        add_log.reset_mock()
-        report_store.log_http_request("method", "url", "body",
-                "headers", ValueError("Foo"))
-        add_log.assert_called_once_with({
-            'type': 'http_request',
-            'method': 'method',
-            'url': 'url',
-            'body': 'body',
-            'headers': 'headers',
-            'status': -1,
-            'response': None,
-            'error': 'ValueError',
-            'error_message': 'Foo',
-            })
+            add_log.reset_mock()
+            report_store.log_http_request("method", "url", "body",
+                    "headers", ValueError("Foo"))
+            add_log.assert_called_once_with({
+                'type': 'http_request',
+                'method': 'method',
+                'url': 'url',
+                'body': 'body',
+                'headers': 'headers',
+                'status': -1,
+                'response': None,
+                'error': 'ValueError',
+                'error_message': 'Foo',
+                })
+
+        with self.subTest(no_http_dup=True, duplicate=True):
+            self.m.user_id = 1
+            self.m.market_id = 3
+            report_store = market.ReportStore(self.m, no_http_dup=True)
+            original_add_log = report_store.add_log
+            with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
+                report_store.log_http_request("method", "url", "body",
+                        "headers", response)
+                report_store.log_http_request("method", "url", "body",
+                        "headers", response)
+                self.assertEqual(2, add_log.call_count)
+                self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
+                self.assertIsNone(add_log.mock_calls[1][1][0]["response"])
+                self.assertEqual(add_log.mock_calls[0][1][0]["date"], add_log.mock_calls[1][1][0]["response_same_as"])
+        with self.subTest(no_http_dup=True, duplicate=False, case="Different call"):
+            self.m.user_id = 1
+            self.m.market_id = 3
+            report_store = market.ReportStore(self.m, no_http_dup=True)
+            original_add_log = report_store.add_log
+            with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
+                report_store.log_http_request("method", "url", "body",
+                        "headers", response)
+                report_store.log_http_request("method2", "url", "body",
+                        "headers", response)
+                self.assertEqual(2, add_log.call_count)
+                self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
+                self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"])
+        with self.subTest(no_http_dup=True, duplicate=False, case="Call inbetween"):
+            self.m.user_id = 1
+            self.m.market_id = 3
+            report_store = market.ReportStore(self.m, no_http_dup=True)
+            original_add_log = report_store.add_log
+
+            response2 = mock.Mock()
+            response2.status_code = 200
+            response2.text = "Hey there!"
+
+            with mock.patch.object(report_store, "add_log", side_effect=original_add_log) as add_log:
+                report_store.log_http_request("method", "url", "body",
+                        "headers", response)
+                report_store.log_http_request("method", "url", "body",
+                        "headers", response2)
+                report_store.log_http_request("method", "url", "body",
+                        "headers", response)
+                self.assertEqual(3, add_log.call_count)
+                self.assertIsNone(add_log.mock_calls[0][1][0]["response_same_as"])
+                self.assertIsNone(add_log.mock_calls[1][1][0]["response_same_as"])
+                self.assertIsNone(add_log.mock_calls[2][1][0]["response_same_as"])
 
     @mock.patch.object(market.ReportStore, "add_log")
     def test_log_market(self, add_log):
         report_store = market.ReportStore(self.m)
 
-        report_store.log_market(self.market_args(debug=True, quiet=False), 4, 1)
+        report_store.log_market(self.market_args(debug=True, quiet=False))
         add_log.assert_called_once_with({
             "type": "market",
             "commit": "$Format:%H$",
             "args": { "report_path": None, "debug": True, "quiet": False },
-            "user_id": 4,
-            "market_id": 1,
             })
 
     @mock.patch.object(market.ReportStore, "print_log")
@@ -1034,7 +1092,7 @@ class PortfolioTest(WebMockTestCase):
                     'SC':   (D("0.0623"), "long"),
                     'ZEC':  (D("0.3701"), "long"),
                     }
-            date = portfolio.datetime(2018, 1, 8)
+            date = portfolio.datetime.datetime(2018, 1, 8)
             self.assertDictEqual(expected, liquidities["high"][date])
 
             expected = {
@@ -1051,7 +1109,7 @@ class PortfolioTest(WebMockTestCase):
                     'XCP':  (D("0.1"), "long"),
                     }
             self.assertDictEqual(expected, liquidities["medium"][date])
-            self.assertEqual(portfolio.datetime(2018, 1, 15), market.Portfolio.last_date.get())
+            self.assertEqual(portfolio.datetime.datetime(2018, 1, 15), market.Portfolio.last_date.get())
 
         with self.subTest(description="Missing weight"):
             data = store.json.loads(self.json_response, parse_int=D, parse_float=D)
@@ -1105,9 +1163,9 @@ class PortfolioTest(WebMockTestCase):
             else:
                 self.assertFalse(refetch)
             self.call_count += 1
-            market.Portfolio.last_date = store.LockedVar(store.datetime.now()\
-                - store.timedelta(10)\
-                + store.timedelta(self.call_count))
+            market.Portfolio.last_date = store.LockedVar(store.datetime.datetime.now()\
+                - store.datetime.timedelta(10)\
+                + store.datetime.timedelta(self.call_count))
         get_cryptoportfolio.side_effect = _get
 
         market.Portfolio.wait_for_recent()
@@ -1166,6 +1224,19 @@ class PortfolioTest(WebMockTestCase):
             self.assertTrue(store.Portfolio.worker_started)
 
             self.assertFalse(store.Portfolio.worker.is_alive())
+            self.assertEqual(1, threading.active_count())
+
+    def test_stop_worker(self):
+        with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\
+                mock.patch.object(store.Portfolio, "report") as report,\
+                mock.patch.object(store.time, "sleep") as sleep:
+            store.Portfolio.start_worker(poll=3)
+            store.Portfolio.stop_worker()
+            store.Portfolio.worker.join()
+            get.assert_not_called()
+            report.assert_not_called()
+            sleep.assert_not_called()
+            self.assertFalse(store.Portfolio.worker.is_alive())
 
     def test_wait_for_notification(self):
         with self.assertRaises(RuntimeError):
@@ -1189,7 +1260,7 @@ class PortfolioTest(WebMockTestCase):
             store.Portfolio.callback.clear()
             store.Portfolio.worker_started = False
             store.Portfolio.worker_notify.set()
-            store.Portfolio.callback.wait()
+            store.Portfolio.worker.join()
             self.assertFalse(store.Portfolio.worker.is_alive())
 
     def test_notify_and_wait(self):