import threading
import market, portfolio, store
+@unittest.skipUnless("unit" in limits, "Unit skipped")
class NoopLockTest(unittest.TestCase):
def test_with(self):
noop_lock = store.NoopLock()
with noop_lock:
self.assertTrue(True)
+@unittest.skipUnless("unit" in limits, "Unit skipped")
class LockedVarTest(unittest.TestCase):
def test_values(self):
thread3.join()
self.assertEqual("Bar", locked_var.get()[0:3])
+@unittest.skipUnless("unit" in limits, "Unit skipped")
class TradeStoreTest(WebMockTestCase):
def test_compute_trades(self):
self.m.balances.currencies.return_value = ["XMR", "DASH", "XVG", "BTC", "ETH"]
self.assertEqual([trade_mock1, trade_mock2], trade_store.pending)
+@unittest.skipUnless("unit" in limits, "Unit skipped")
class BalanceStoreTest(WebMockTestCase):
def setUp(self):
super().setUp()
balance_store = market.BalanceStore(self.m)
- balance_store.fetch_balances()
- self.assertNotIn("ETC", balance_store.currencies())
- self.assertListEqual(["USDT", "XVG", "XMR"], list(balance_store.currencies()))
+ with self.subTest(log_tickers=False):
+ balance_store.fetch_balances()
+ self.assertNotIn("ETC", balance_store.currencies())
+ self.assertListEqual(["USDT", "XVG", "XMR"], list(balance_store.currencies()))
+
+ balance_store.all["ETC"] = portfolio.Balance("ETC", {
+ "exchange_total": "1", "exchange_free": "0",
+ "exchange_used": "1" })
+ balance_store.fetch_balances(tag="foo")
+ self.assertEqual(0, balance_store.all["ETC"].total)
+ self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies()))
+ self.m.report.log_balances.assert_called_with(tag="foo", checkpoint=None)
+
+ with self.subTest(log_tickers=True),\
+ mock.patch.object(balance_store, "in_currency") as in_currency:
+ in_currency.return_value = "tickers"
+ balance_store.fetch_balances(log_tickers=True, ticker_currency="FOO",
+ ticker_compute_value="compute", ticker_type="type")
+ self.m.report.log_balances.assert_called_with(compute_value='compute',
+ tag=None, checkpoint=None, ticker_currency='FOO', tickers='tickers',
+ type='type')
+
+ balance_store = market.BalanceStore(self.m)
+ with self.subTest(add_portfolio=True),\
+ mock.patch.object(market.Portfolio, "repartition") as repartition:
+ repartition.return_value = {
+ "DOGE": D("0.5"),
+ "USDT": D("0.5"),
+ }
+ balance_store.fetch_balances(add_portfolio=True)
+ self.assertListEqual(["USDT", "XVG", "XMR", "DOGE"], list(balance_store.currencies()))
+
+ self.m.ccxt.fetch_all_balances.return_value = {
+ "ETC": {
+ "exchange_free": 0,
+ "exchange_used": 0,
+ "exchange_total": 0,
+ "margin_total": 0,
+ },
+ "XVG": {
+ "exchange_free": 16,
+ "exchange_used": 0,
+ "exchange_total": 16,
+ "margin_total": 0,
+ },
+ "XMR": {
+ "exchange_free": 0,
+ "exchange_used": 0,
+ "exchange_total": 0,
+ "margin_total": D("-1.0"),
+ "margin_free": 0,
+ },
+ }
- balance_store.all["ETC"] = portfolio.Balance("ETC", {
- "exchange_total": "1", "exchange_free": "0",
- "exchange_used": "1" })
- balance_store.fetch_balances(tag="foo")
- self.assertEqual(0, balance_store.all["ETC"].total)
- self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies()))
- self.m.report.log_balances.assert_called_with(tag="foo")
+ balance_store = market.BalanceStore(self.m)
+ with self.subTest(add_usdt=True),\
+ mock.patch.object(market.Portfolio, "repartition") as repartition:
+ repartition.return_value = {
+ "DOGE": D("0.5"),
+ "ETH": D("0.5"),
+ }
+ balance_store.fetch_balances(add_usdt=True)
+ self.assertListEqual(["XVG", "XMR", "USDT"], list(balance_store.currencies()))
+
+ @mock.patch.object(market.Portfolio, "repartition")
+ def test_available_balances_for_repartition(self, repartition):
+ with self.subTest(available_balance_only=True):
+ def _get_ticker(c1, c2):
+ if c1 == "ZRC" and c2 == "BTC":
+ return { "average": D("0.0001") }
+ if c1 == "DOGE" and c2 == "BTC":
+ return { "average": D("0.000001") }
+ if c1 == "ETH" and c2 == "BTC":
+ return { "average": D("0.1") }
+ if c1 == "FOO" and c2 == "BTC":
+ return { "average": D("0.1") }
+ self.fail("Should not be called with {}, {}".format(c1, c2))
+ self.m.get_ticker.side_effect = _get_ticker
+
+ repartition.return_value = {
+ "DOGE": (D("0.20"), "short"),
+ "BTC": (D("0.20"), "long"),
+ "ETH": (D("0.20"), "long"),
+ "XMR": (D("0.20"), "long"),
+ "FOO": (D("0.20"), "long"),
+ }
+ self.m.ccxt.fetch_all_balances.return_value = {
+ "ZRC": {
+ "exchange_free": D("2.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("2.0"),
+ "total": D("2.0")
+ },
+ "DOGE": {
+ "exchange_free": D("5.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("5.0"),
+ "total": D("5.0")
+ },
+ "BTC": {
+ "exchange_free": D("0.065"),
+ "exchange_used": D("0.02"),
+ "exchange_total": D("0.085"),
+ "margin_available": D("0.035"),
+ "margin_in_position": D("0.01"),
+ "margin_total": D("0.045"),
+ "total": D("0.13")
+ },
+ "ETH": {
+ "exchange_free": D("1.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("1.0"),
+ "total": D("1.0")
+ },
+ "FOO": {
+ "exchange_free": D("0.1"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("0.1"),
+ "total": D("0.1"),
+ },
+ }
+
+ balance_store = market.BalanceStore(self.m)
+ balance_store.fetch_balances()
+ _repartition, total_base_value, amount_in_position = balance_store.available_balances_for_repartition()
+ repartition.assert_called_with(liquidity="medium")
+ self.assertEqual((D("0.20"), "short"), _repartition["DOGE"])
+ self.assertEqual((D("0.20"), "long"), _repartition["BTC"])
+ self.assertEqual((D("0.20"), "long"), _repartition["XMR"])
+ self.assertEqual((D("0.20"), "long"), _repartition["FOO"])
+ self.assertIsNone(_repartition.get("ETH"))
+ self.assertEqual(portfolio.Amount("BTC", "0.1"), total_base_value)
+ self.assertEqual(0, amount_in_position["DOGE"])
+ self.assertEqual(0, amount_in_position["BTC"])
+ self.assertEqual(0, amount_in_position["XMR"])
+ self.assertEqual(portfolio.Amount("BTC", "0.1"), amount_in_position["ETH"])
+ self.assertEqual(portfolio.Amount("BTC", "0.01"), amount_in_position["FOO"])
+
+ with self.subTest(available_balance_only=True, balance=0):
+ def _get_ticker(c1, c2):
+ if c1 == "ETH" and c2 == "BTC":
+ return { "average": D("0.1") }
+ self.fail("Should not be called with {}, {}".format(c1, c2))
+ self.m.get_ticker.side_effect = _get_ticker
+
+ repartition.return_value = {
+ "BTC": (D("0.5"), "long"),
+ "ETH": (D("0.5"), "long"),
+ }
+ self.m.ccxt.fetch_all_balances.return_value = {
+ "ETH": {
+ "exchange_free": D("1.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("1.0"),
+ "total": D("1.0")
+ },
+ }
+
+ balance_store = market.BalanceStore(self.m)
+ balance_store.fetch_balances()
+ _repartition, total_base_value, amount_in_position = balance_store.available_balances_for_repartition(liquidity="high")
+
+ repartition.assert_called_with(liquidity="high")
+ self.assertEqual((D("0.5"), "long"), _repartition["BTC"])
+ self.assertIsNone(_repartition.get("ETH"))
+ self.assertEqual(0, total_base_value)
+ self.assertEqual(0, amount_in_position["BTC"])
+ self.assertEqual(0, amount_in_position["BTC"])
+
+ repartition.reset_mock()
+ with self.subTest(available_balance_only=True, balance=0,
+ repartition="present"):
+ def _get_ticker(c1, c2):
+ if c1 == "ETH" and c2 == "BTC":
+ return { "average": D("0.1") }
+ self.fail("Should not be called with {}, {}".format(c1, c2))
+ self.m.get_ticker.side_effect = _get_ticker
+
+ _repartition = {
+ "BTC": (D("0.5"), "long"),
+ "ETH": (D("0.5"), "long"),
+ }
+ self.m.ccxt.fetch_all_balances.return_value = {
+ "ETH": {
+ "exchange_free": D("1.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("1.0"),
+ "total": D("1.0")
+ },
+ }
+
+ balance_store = market.BalanceStore(self.m)
+ balance_store.fetch_balances()
+ _repartition, total_base_value, amount_in_position = balance_store.available_balances_for_repartition(repartition=_repartition)
+ repartition.assert_not_called()
+
+ self.assertEqual((D("0.5"), "long"), _repartition["BTC"])
+ self.assertIsNone(_repartition.get("ETH"))
+ self.assertEqual(0, total_base_value)
+ self.assertEqual(0, amount_in_position["BTC"])
+ self.assertEqual(portfolio.Amount("BTC", "0.1"), amount_in_position["ETH"])
+
+ repartition.reset_mock()
+ with self.subTest(available_balance_only=True, balance=0,
+ repartition="present", base_currency="ETH"):
+ def _get_ticker(c1, c2):
+ if c1 == "ETH" and c2 == "BTC":
+ return { "average": D("0.1") }
+ self.fail("Should not be called with {}, {}".format(c1, c2))
+ self.m.get_ticker.side_effect = _get_ticker
+
+ _repartition = {
+ "BTC": (D("0.5"), "long"),
+ "ETH": (D("0.5"), "long"),
+ }
+ self.m.ccxt.fetch_all_balances.return_value = {
+ "ETH": {
+ "exchange_free": D("1.0"),
+ "exchange_used": D("0.0"),
+ "exchange_total": D("1.0"),
+ "total": D("1.0")
+ },
+ }
+
+ balance_store = market.BalanceStore(self.m)
+ balance_store.fetch_balances()
+ _repartition, total_base_value, amount_in_position = balance_store.available_balances_for_repartition(repartition=_repartition, base_currency="ETH")
+
+ self.assertEqual((D("0.5"), "long"), _repartition["BTC"])
+ self.assertEqual((D("0.5"), "long"), _repartition["ETH"])
+ self.assertEqual(portfolio.Amount("ETH", 1), total_base_value)
+ self.assertEqual(0, amount_in_position["BTC"])
+ self.assertEqual(0, amount_in_position["ETH"])
@mock.patch.object(market.Portfolio, "repartition")
def test_dispatch_assets(self, repartition):
self.assertEqual(D("2.6"), amounts["BTC"].value)
self.assertEqual(D("7.5"), amounts["XEM"].value)
self.assertEqual(D("-1.0"), amounts["DASH"].value)
- self.m.report.log_balances.assert_called_with(tag=None)
+ self.m.report.log_balances.assert_called_with(tag=None, checkpoint=None)
self.m.report.log_dispatch.assert_called_once_with(portfolio.Amount("BTC",
"11.1"), amounts, "medium", repartition_hash)
self.assertEqual(1, as_json["BTC"])
self.assertEqual(2, as_json["ETH"])
+@unittest.skipUnless("unit" in limits, "Unit skipped")
class ReportStoreTest(WebMockTestCase):
def test_add_log(self):
with self.subTest(market=self.m):
self.assertEqual({"foo": "bar", "date": mock.ANY, "user_id": None, "market_id": None}, result)
+ def test_add_redis_status(self):
+ report_store = market.ReportStore(self.m)
+ result = report_store.add_redis_status({"foo": "bar"})
+
+ self.assertEqual({"foo": "bar"}, result)
+ self.assertEqual(result, report_store.redis_status[0])
+
def test_set_verbose(self):
report_store = market.ReportStore(self.m)
with self.subTest(verbose=True):
self.assertEqual(("date1", "type1", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs[0])
self.assertEqual(("date2", "type2", '{\n "foo": "bar",\n "bla": "bla"\n}'), logs[1])
+ def test_to_json_redis(self):
+ report_store = market.ReportStore(self.m)
+ report_store.redis_status.append({
+ "type": "type1", "foo": "bar", "bla": "bla"
+ })
+ report_store.redis_status.append({
+ "type": "type2", "foo": "bar", "bla": "bla"
+ })
+ logs = list(report_store.to_json_redis())
+
+ self.assertEqual(2, len(logs))
+ self.assertEqual(("type1", '{"foo": "bar", "bla": "bla"}'), logs[0])
+ self.assertEqual(("type2", '{"foo": "bar", "bla": "bla"}'), logs[1])
+
@mock.patch.object(market.ReportStore, "print_log")
@mock.patch.object(market.ReportStore, "add_log")
def test_log_stage(self, add_log, print_log):
@mock.patch.object(market.ReportStore, "print_log")
@mock.patch.object(market.ReportStore, "add_log")
- def test_log_balances(self, add_log, print_log):
+ @mock.patch.object(market.ReportStore, "add_redis_status")
+ def test_log_balances(self, add_redis_status, add_log, print_log):
report_store = market.ReportStore(self.m)
self.m.balances.as_json.return_value = "json"
self.m.balances.all = { "FOO": "bar", "BAR": "baz" }
- report_store.log_balances(tag="tag")
- print_log.assert_has_calls([
- mock.call("[Balance]"),
- mock.call("\tbar"),
- mock.call("\tbaz"),
- ])
- add_log.assert_called_once_with({
- 'type': 'balance',
- 'balances': 'json',
- 'tag': 'tag'
- })
+ with self.subTest(tickers=None):
+ report_store.log_balances(tag="tag")
+ print_log.assert_has_calls([
+ mock.call("[Balance]"),
+ mock.call("\tbar"),
+ mock.call("\tbaz"),
+ ])
+ add_log.assert_called_once_with({
+ 'type': 'balance',
+ 'checkpoint': None,
+ 'balances': 'json',
+ 'tag': 'tag'
+ })
+ add_redis_status.assert_called_once_with({
+ 'type': 'balance',
+ 'balances': 'json',
+ 'checkpoint': None,
+ 'tag': 'tag'
+ })
+ add_log.reset_mock()
+ add_redis_status.reset_mock()
+ with self.subTest(tickers="present"):
+ amounts = {
+ "BTC": portfolio.Amount("BTC", 10),
+ "ETH": portfolio.Amount("BTC", D("0.3"))
+ }
+ amounts["ETH"].rate = D("0.1")
+
+ report_store.log_balances(tag="tag", tickers=amounts,
+ ticker_currency="BTC", compute_value="default",
+ type="total")
+ add_log.assert_called_once_with({
+ 'type': 'balance',
+ 'checkpoint': None,
+ 'balances': 'json',
+ 'tag': 'tag',
+ 'tickers': {
+ 'compute_value': 'default',
+ 'balance_type': 'total',
+ 'currency': 'BTC',
+ 'balances': {
+ 'BTC': D('10'),
+ 'ETH': D('0.3')
+ },
+ 'rates': {
+ 'BTC': None,
+ 'ETH': D('0.1')
+ },
+ 'total': D('10.3')
+ },
+ })
+ add_redis_status.assert_called_once_with({
+ 'type': 'balance',
+ 'checkpoint': None,
+ 'balances': 'json',
+ 'tag': 'tag',
+ 'tickers': {
+ 'compute_value': 'default',
+ 'balance_type': 'total',
+ 'currency': 'BTC',
+ 'balances': {
+ 'BTC': D('10'),
+ 'ETH': D('0.3')
+ },
+ 'rates': {
+ 'BTC': None,
+ 'ETH': D('0.1')
+ },
+ 'total': D('10.3')
+ },
+ })
@mock.patch.object(market.ReportStore, "print_log")
@mock.patch.object(market.ReportStore, "add_log")
'action': 'Hey'
})
+@unittest.skipUnless("unit" in limits, "Unit skipped")
class PortfolioTest(WebMockTestCase):
def setUp(self):
super().setUp()
self.wm.get(market.Portfolio.URL, text=self.json_response)
@mock.patch.object(market.Portfolio, "parse_cryptoportfolio")
- def test_get_cryptoportfolio(self, parse_cryptoportfolio):
+ @mock.patch.object(market.Portfolio, "store_cryptoportfolio")
+ def test_get_cryptoportfolio(self, store_cryptoportfolio, parse_cryptoportfolio):
with self.subTest(parallel=False):
self.wm.get(market.Portfolio.URL, [
{"text":'{ "foo": "bar" }', "status_code": 200},
market.Portfolio.report.log_error.assert_not_called()
market.Portfolio.report.log_http_request.assert_called_once()
parse_cryptoportfolio.assert_called_once_with()
+ store_cryptoportfolio.assert_called_once_with()
market.Portfolio.report.log_http_request.reset_mock()
parse_cryptoportfolio.reset_mock()
+ store_cryptoportfolio.reset_mock()
market.Portfolio.data = store.LockedVar(None)
market.Portfolio.get_cryptoportfolio()
self.assertIsNone(market.Portfolio.data.get())
self.assertEqual(2, self.wm.call_count)
parse_cryptoportfolio.assert_not_called()
+ store_cryptoportfolio.assert_not_called()
market.Portfolio.report.log_error.assert_not_called()
market.Portfolio.report.log_http_request.assert_called_once()
market.Portfolio.report.log_http_request.reset_mock()
parse_cryptoportfolio.reset_mock()
+ store_cryptoportfolio.reset_mock()
market.Portfolio.data = store.LockedVar("Foo")
market.Portfolio.get_cryptoportfolio()
self.assertEqual(2, self.wm.call_count)
parse_cryptoportfolio.assert_not_called()
+ store_cryptoportfolio.assert_not_called()
market.Portfolio.get_cryptoportfolio(refetch=True)
self.assertEqual("Foo", market.Portfolio.data.get())
market.Portfolio.get_cryptoportfolio()
self.assertIn("foo", market.Portfolio.data.get())
parse_cryptoportfolio.reset_mock()
+ store_cryptoportfolio.reset_mock()
with self.subTest(worker=False):
market.Portfolio.data = store.LockedVar(None)
market.Portfolio.worker = mock.Mock()
+ market.Portfolio.worker_started = True
is_worker.return_value = False
market.Portfolio.get_cryptoportfolio()
notify.assert_called_once_with()
parse_cryptoportfolio.assert_not_called()
+ store_cryptoportfolio.assert_not_called()
+ with self.subTest(worker_started=False):
+ market.Portfolio.data = store.LockedVar(None)
+ market.Portfolio.worker = mock.Mock()
+ market.Portfolio.worker_started = False
+ is_worker.return_value = False
+ with self.assertRaises(Exception):
+ market.Portfolio.get_cryptoportfolio()
def test_parse_cryptoportfolio(self):
with self.subTest(description="Normal case"):
del(data["portfolio_2"]["weights"])
market.Portfolio.data = store.LockedVar(data)
- market.Portfolio.parse_cryptoportfolio()
- self.assertListEqual(
- ["medium", "high"],
- list(market.Portfolio.liquidities.get().keys()))
- self.assertEqual({}, market.Portfolio.liquidities.get("medium"))
-
- with self.subTest(description="All missing weights"):
- data = store.json.loads(self.json_response, parse_int=D, parse_float=D)
- del(data["portfolio_1"]["weights"])
- del(data["portfolio_2"]["weights"])
- market.Portfolio.data = store.LockedVar(data)
-
- market.Portfolio.parse_cryptoportfolio()
- self.assertEqual({}, market.Portfolio.liquidities.get("medium"))
- self.assertEqual({}, market.Portfolio.liquidities.get("high"))
- self.assertEqual(datetime.datetime(1,1,1), market.Portfolio.last_date.get())
+ with self.assertRaises(AssertionError):
+ market.Portfolio.parse_cryptoportfolio()
-
- @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
- def test_repartition(self, get_cryptoportfolio):
- market.Portfolio.liquidities = store.LockedVar({
+ @mock.patch.object(store.dbs, "redis_connected")
+ @mock.patch.object(store.dbs, "redis")
+ def test_store_cryptoportfolio(self, redis, redis_connected):
+ store.Portfolio.liquidities = store.LockedVar({
"medium": {
- "2018-03-01": "medium_2018-03-01",
- "2018-03-08": "medium_2018-03-08",
+ datetime.datetime(2018,3,1): "medium_2018-03-01",
+ datetime.datetime(2018,3,8): "medium_2018-03-08",
},
"high": {
- "2018-03-01": "high_2018-03-01",
- "2018-03-08": "high_2018-03-08",
+ datetime.datetime(2018,3,1): "high_2018-03-01",
+ datetime.datetime(2018,3,8): "high_2018-03-08",
}
})
- market.Portfolio.last_date = store.LockedVar("2018-03-08")
+ store.Portfolio.last_date = store.LockedVar(datetime.datetime(2018,3,8))
+
+ with self.subTest(redis_connected=False):
+ redis_connected.return_value = False
+ store.Portfolio.store_cryptoportfolio()
+ redis.set.assert_not_called()
+
+ with self.subTest(redis_connected=True):
+ redis_connected.return_value = True
+ store.Portfolio.store_cryptoportfolio()
+ redis.set.assert_has_calls([
+ mock.call("/cryptoportfolio/repartition/latest", '{"medium": "medium_2018-03-08", "high": "high_2018-03-08"}'),
+ mock.call("/cryptoportfolio/repartition/date", "2018-03-08"),
+ ])
+
+ @mock.patch.object(store.dbs, "redis_connected")
+ @mock.patch.object(store.dbs, "redis")
+ def test_retrieve_cryptoportfolio(self, redis, redis_connected):
+ with self.subTest(redis_connected=False):
+ redis_connected.return_value = False
+ store.Portfolio.retrieve_cryptoportfolio()
+ redis.get.assert_not_called()
+ self.assertIsNone(store.Portfolio.data.get())
+
+ with self.subTest(redis_connected=True, value=None):
+ redis_connected.return_value = True
+ redis.get.return_value = None
+ store.Portfolio.retrieve_cryptoportfolio()
+ self.assertEqual(2, redis.get.call_count)
+
+ redis.reset_mock()
+ with self.subTest(redis_connected=True, value="present"):
+ redis_connected.return_value = True
+ redis.get.side_effect = [
+ b'{ "medium": "medium_repartition", "high": "high_repartition" }',
+ b"2018-03-08"
+ ]
+ store.Portfolio.retrieve_cryptoportfolio()
+ self.assertEqual(2, redis.get.call_count)
+ self.assertEqual(datetime.datetime(2018,3,8), store.Portfolio.last_date.get())
+ self.assertEqual("", store.Portfolio.data.get())
+ expected_liquidities = {
+ 'high': { datetime.datetime(2018, 3, 8): 'high_repartition' },
+ 'medium': { datetime.datetime(2018, 3, 8): 'medium_repartition' },
+ }
+ self.assertEqual(expected_liquidities, store.Portfolio.liquidities.get())
+
+ @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
+ @mock.patch.object(market.Portfolio, "retrieve_cryptoportfolio")
+ def test_repartition(self, retrieve_cryptoportfolio, get_cryptoportfolio):
+ with self.subTest(from_cache=False):
+ market.Portfolio.liquidities = store.LockedVar({
+ "medium": {
+ "2018-03-01": ["medium_2018-03-01"],
+ "2018-03-08": ["medium_2018-03-08"],
+ },
+ "high": {
+ "2018-03-01": ["high_2018-03-01"],
+ "2018-03-08": ["high_2018-03-08"],
+ }
+ })
+ market.Portfolio.last_date = store.LockedVar("2018-03-08")
+
+ self.assertEqual(["medium_2018-03-08"], market.Portfolio.repartition())
+ get_cryptoportfolio.assert_called_once_with()
+ retrieve_cryptoportfolio.assert_not_called()
+ self.assertEqual(["medium_2018-03-08"], market.Portfolio.repartition(liquidity="medium"))
+ self.assertEqual(["high_2018-03-08"], market.Portfolio.repartition(liquidity="high"))
+
+ retrieve_cryptoportfolio.reset_mock()
+ get_cryptoportfolio.reset_mock()
+
+ with self.subTest(from_cache=True):
+ self.assertEqual(["medium_2018-03-08"], market.Portfolio.repartition(from_cache=True))
+ get_cryptoportfolio.assert_called_once_with()
+ retrieve_cryptoportfolio.assert_called_once_with()
+
+ retrieve_cryptoportfolio.reset_mock()
+ get_cryptoportfolio.reset_mock()
- self.assertEqual("medium_2018-03-08", market.Portfolio.repartition())
- get_cryptoportfolio.assert_called_once_with()
- self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(liquidity="medium"))
- self.assertEqual("high_2018-03-08", market.Portfolio.repartition(liquidity="high"))
+ with self.subTest("absent liquidities"):
+ market.Portfolio.last_date = store.LockedVar("2018-03-15")
+ self.assertIsNone(market.Portfolio.repartition())
+
+ with self.subTest("no liquidities"):
+ market.Portfolio.liquidities = store.LockedVar({})
+ market.Portfolio.last_date = store.LockedVar("2018-03-08")
+ self.assertIsNone(market.Portfolio.repartition())
@mock.patch.object(market.time, "sleep")
@mock.patch.object(market.Portfolio, "get_cryptoportfolio")
- def test_wait_for_recent(self, get_cryptoportfolio, sleep):
+ @mock.patch.object(market.Portfolio, "next_wait_time")
+ def test_wait_for_recent(self, next_wait_time, get_cryptoportfolio, sleep):
self.call_count = 0
def _get(refetch=False):
if self.call_count != 0:
- store.datetime.timedelta(10)\
+ store.datetime.timedelta(self.call_count))
get_cryptoportfolio.side_effect = _get
+ next_wait_time.return_value = 30
market.Portfolio.wait_for_recent()
sleep.assert_called_with(30)
def test_start_worker(self):
with mock.patch.object(store.Portfolio, "wait_for_notification") as notification:
store.Portfolio.start_worker()
- notification.assert_called_once_with(poll=30)
+ notification.assert_called_once_with()
self.assertEqual("lock", store.Portfolio.last_date.lock.__class__.__name__)
self.assertEqual("lock", store.Portfolio.liquidities.lock.__class__.__name__)
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.start_worker()
store.Portfolio.stop_worker()
store.Portfolio.worker.join()
get.assert_not_called()
with mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\
mock.patch.object(store.Portfolio, "report") as report,\
+ mock.patch.object(store.Portfolio, "next_wait_time") as wait,\
mock.patch.object(store.time, "sleep") as sleep:
- store.Portfolio.start_worker(poll=3)
+ wait.return_value = 3
+ store.Portfolio.start_worker()
store.Portfolio.worker_notify.set()
store.Portfolio.worker.join()
self.assertFalse(store.Portfolio.worker.is_alive())
+ with self.subTest("overdue"),\
+ mock.patch.object(store.Portfolio, "get_cryptoportfolio") as get,\
+ mock.patch.object(store.Portfolio, "report") as report,\
+ mock.patch.object(store.Portfolio, "next_wait_time") as wait,\
+ mock.patch.object(store.time, "sleep") as sleep:
+ wait.side_effect = Exception("Time over")
+ store.Portfolio.start_worker()
+
+ store.Portfolio.worker_notify.set()
+
+ store.Portfolio.callback.wait()
+
+ report.print_log.assert_called_once_with("[Worker] Fetching cryptoportfolio")
+ get.assert_called_once_with(refetch=True)
+ self.assertFalse(store.Portfolio.worker.is_alive())
+
def test_notify_and_wait(self):
with mock.patch.object(store.Portfolio, "callback") as callback,\
mock.patch.object(store.Portfolio, "worker_notify") as worker_notify:
worker_notify.set.assert_called_once_with()
callback.wait.assert_called_once_with()
+ def test_next_wait_time(self):
+ with self.subTest("first start"):
+ self.assertEqual(30, store.Portfolio.next_wait_time())
+ self.assertIsNotNone(store.Portfolio.poll_started_at)
+ with self.subTest("25min"):
+ store.Portfolio.poll_started_at = datetime.datetime.now() - datetime.timedelta(minutes=25)
+ self.assertEqual(30, store.Portfolio.next_wait_time())
+ with self.subTest("35min"):
+ store.Portfolio.poll_started_at = datetime.datetime.now() - datetime.timedelta(minutes=35)
+ self.assertEqual(60, store.Portfolio.next_wait_time())
+ with self.subTest("1h15"):
+ store.Portfolio.poll_started_at = datetime.datetime.now() - datetime.timedelta(minutes=75)
+ self.assertEqual(300, store.Portfolio.next_wait_time())
+ with self.subTest("5hours"):
+ store.Portfolio.poll_started_at = datetime.datetime.now() - datetime.timedelta(hours=5)
+ self.assertEqual(3600, store.Portfolio.next_wait_time())
+ with self.subTest("overdue"), self.assertRaises(Exception):
+ store.Portfolio.poll_started_at = datetime.datetime.now() - datetime.timedelta(hours=25)
+ store.Portfolio.next_wait_time()
+
projects / perso / Immae / Projets / Cryptomonnaies / Cryptoportfolio / Trader.git / blobdiff