test.py

   1 import portfolio
   2 import unittest
   3 from unittest import mock
   4
   5 class AmountTest(unittest.TestCase):
   6     def test_values(self):
   7         amount = portfolio.Amount("BTC", 0.65)
   8         self.assertEqual(0.65, amount.value)
   9         self.assertEqual("BTC", amount.currency)
  10
  11         amount = portfolio.Amount("BTC", 10, int_val=2000000000000000)
  12         self.assertEqual(0.002, amount.value)
  13
  14     def test_in_currency(self):
  15         amount = portfolio.Amount("ETC", 10)
  16
  17         self.assertEqual(amount, amount.in_currency("ETC", None))
  18
  19         ticker_mock = unittest.mock.Mock()
  20         with mock.patch.object(portfolio.Amount, 'get_ticker', new=ticker_mock):
  21             ticker_mock.return_value = None
  22             portfolio.Amount.get_ticker = ticker_mock
  23
  24             self.assertRaises(Exception, amount.in_currency, "ETH", None)
  25
  26         with mock.patch.object(portfolio.Amount, 'get_ticker', new=ticker_mock):
  27             ticker_mock.return_value = {
  28                     "average": 0.3,
  29                     "foo": "bar",
  30                     }
  31             converted_amount = amount.in_currency("ETH", None)
  32
  33             self.assertEqual(3.0, converted_amount.value)
  34             self.assertEqual("ETH", converted_amount.currency)
  35             self.assertEqual(amount, converted_amount.linked_to)
  36             self.assertEqual("bar", converted_amount.ticker["foo"])
  37
  38     @unittest.skip("TODO")
  39     def test_get_ticker(self):
  40         pass
  41
  42     def test__abs(self):
  43         amount = portfolio.Amount("SC", -120)
  44         self.assertEqual(120, abs(amount).value)
  45         self.assertEqual("SC", abs(amount).currency)
  46
  47         amount = portfolio.Amount("SC", 10)
  48         self.assertEqual(10, abs(amount).value)
  49         self.assertEqual("SC", abs(amount).currency)
  50
  51     def test__add(self):
  52         amount1 = portfolio.Amount("XVG", 12.9)
  53         amount2 = portfolio.Amount("XVG", 13.1)
  54
  55         self.assertEqual(26, (amount1 + amount2).value)
  56         self.assertEqual("XVG", (amount1 + amount2).currency)
  57
  58         amount3 = portfolio.Amount("ETH", 1.6)
  59         with self.assertRaises(Exception):
  60             amount1 + amount3
  61
  62         amount4 = portfolio.Amount("ETH", 0.0)
  63         self.assertEqual(amount1, amount1 + amount4)
  64
  65     def test__radd(self):
  66         amount = portfolio.Amount("XVG", 12.9)
  67
  68         self.assertEqual(amount, 0 + amount)
  69         with self.assertRaises(Exception):
  70             4 + amount
  71
  72     def test__sub(self):
  73         amount1 = portfolio.Amount("XVG", 13.3)
  74         amount2 = portfolio.Amount("XVG", 13.1)
  75
  76         self.assertEqual(0.2, (amount1 - amount2).value)
  77         self.assertEqual("XVG", (amount1 - amount2).currency)
  78
  79         amount3 = portfolio.Amount("ETH", 1.6)
  80         with self.assertRaises(Exception):
  81             amount1 - amount3
  82
  83         amount4 = portfolio.Amount("ETH", 0.0)
  84         self.assertEqual(amount1, amount1 - amount4)
  85
  86     def test__int(self):
  87         amount = portfolio.Amount("XMR", 0.1)
  88         self.assertEqual(100000000000000000, int(amount))
  89
  90     def test__mul(self):
  91         amount = portfolio.Amount("XEM", 11)
  92
  93         self.assertEqual(38.5, (amount * 3.5).value)
  94         self.assertEqual(33, (amount * 3).value)
  95
  96         with self.assertRaises(Exception):
  97             amount * amount
  98
  99     def test__rmul(self):
 100         amount = portfolio.Amount("XEM", 11)
 101
 102         self.assertEqual(38.5, (3.5 * amount).value)
 103         self.assertEqual(33, (3 * amount).value)
 104
 105     def test__floordiv(self):
 106         amount = portfolio.Amount("XEM", 11)
 107
 108         self.assertEqual(5.5, (amount // 2).value)
 109         with self.assertRaises(TypeError):
 110             amount // 2.5
 111         self.assertEqual(1571428571428571428, (amount // 7)._value)
 112
 113     def test__div(self):
 114         amount = portfolio.Amount("XEM", 11)
 115
 116         with self.assertRaises(TypeError):
 117             amount / 2.5
 118         self.assertEqual(5.5, (amount / 2).value)
 119         self.assertEqual(1571428571428571428, (amount / 7)._value)
 120
 121     def test__lt(self):
 122         amount1 = portfolio.Amount("BTD", 11.3)
 123         amount2 = portfolio.Amount("BTD", 13.1)
 124
 125         self.assertTrue(amount1 < amount2)
 126         self.assertFalse(amount2 < amount1)
 127         self.assertFalse(amount1 < amount1)
 128
 129         amount3 = portfolio.Amount("BTC", 1.6)
 130         with self.assertRaises(Exception):
 131             amount1 < amount3
 132
 133     def test__eq(self):
 134         amount1 = portfolio.Amount("BTD", 11.3)
 135         amount2 = portfolio.Amount("BTD", 13.1)
 136         amount3 = portfolio.Amount("BTD", 11.3)
 137
 138         self.assertFalse(amount1 == amount2)
 139         self.assertFalse(amount2 == amount1)
 140         self.assertTrue(amount1 == amount3)
 141         self.assertFalse(amount2 == 0)
 142
 143         amount4 = portfolio.Amount("BTC", 1.6)
 144         with self.assertRaises(Exception):
 145             amount1 == amount4
 146
 147         amount5 = portfolio.Amount("BTD", 0)
 148         self.assertTrue(amount5 == 0)
 149
 150     def test__str(self):
 151         amount1 = portfolio.Amount("BTX", 32)
 152         self.assertEqual("32.00000000 BTX", str(amount1))
 153
 154         amount2 = portfolio.Amount("USDT", 12000)
 155         amount1.linked_to = amount2
 156         self.assertEqual("32.00000000 BTX [12000.00000000 USDT]", str(amount1))
 157
 158     def test__repr(self):
 159         amount1 = portfolio.Amount("BTX", 32)
 160         self.assertEqual("Amount(32.00000000 BTX)", repr(amount1))
 161
 162         amount2 = portfolio.Amount("USDT", 12000)
 163         amount1.linked_to = amount2
 164         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT))", repr(amount1))
 165
 166         amount3 = portfolio.Amount("BTC", 0.1)
 167         amount2.linked_to = amount3
 168         self.assertEqual("Amount(32.00000000 BTX -> Amount(12000.00000000 USDT -> Amount(0.10000000 BTC)))", repr(amount1))
 169
 170 class PortfolioTest(unittest.TestCase):
 171     import urllib3
 172     def fill_data(self):
 173         if self.json_response is not None:
 174             portfolio.Portfolio.data = self.json_response
 175
 176     def setUp(self):
 177         super(PortfolioTest, self).setUp()
 178
 179         with open("test_portfolio.json") as example:
 180             import json
 181             self.json_response = json.load(example)
 182
 183         self.patcher = mock.patch.multiple(portfolio.Portfolio, data=None, liquidities={})
 184         self.patcher.start()
 185
 186     @mock.patch.object(urllib3, "disable_warnings")
 187     @mock.patch.object(urllib3.poolmanager.PoolManager, "request")
 188     @mock.patch.object(portfolio.Portfolio, "URL", new="foo://bar")
 189     def test_get_cryptoportfolio(self, request, disable_warnings):
 190         request.side_effect = [
 191                 type('', (), { "data": '{ "foo": "bar" }' }),
 192                 type('', (), { "data": 'System Error' }),
 193                 Exception("Connection error"),
 194                 ]
 195
 196         portfolio.Portfolio.get_cryptoportfolio()
 197         self.assertIn("foo", portfolio.Portfolio.data)
 198         self.assertEqual("bar", portfolio.Portfolio.data["foo"])
 199         request.assert_called_with("GET", "foo://bar")
 200
 201         request.reset_mock()
 202         portfolio.Portfolio.get_cryptoportfolio()
 203         self.assertIsNone(portfolio.Portfolio.data)
 204         request.assert_called_with("GET", "foo://bar")
 205
 206         request.reset_mock()
 207         portfolio.Portfolio.data = "foo"
 208         portfolio.Portfolio.get_cryptoportfolio()
 209         request.assert_called_with("GET", "foo://bar")
 210         self.assertEqual("foo", portfolio.Portfolio.data)
 211         disable_warnings.assert_called_with()
 212
 213     @mock.patch.object(portfolio.Portfolio, "get_cryptoportfolio")
 214     def test_parse_cryptoportfolio(self, mock_get):
 215         mock_get.side_effect = self.fill_data
 216
 217         portfolio.Portfolio.parse_cryptoportfolio()
 218
 219         self.assertListEqual(
 220                 ["medium", "high"],
 221                 list(portfolio.Portfolio.liquidities.keys()))
 222
 223         liquidities = portfolio.Portfolio.liquidities
 224         self.assertEqual(10, len(liquidities["medium"].keys()))
 225         self.assertEqual(10, len(liquidities["high"].keys()))
 226
 227         expected = {'BTC': 2857, 'DGB': 1015, 'DOGE': 1805, 'SC': 623, 'ZEC': 3701}
 228         self.assertDictEqual(expected, liquidities["high"]['2018-01-08'])
 229
 230         expected = {'ETC': 1000, 'FCT': 1000, 'GAS': 1000, 'NAV': 1000, 'OMG': 1000, 'OMNI': 1000, 'PPC': 1000, 'RIC': 1000, 'VIA': 1000, 'XCP': 1000}
 231         self.assertDictEqual(expected, liquidities["medium"]['2018-01-08'])
 232
 233         # It doesn't refetch the data when available
 234         portfolio.Portfolio.parse_cryptoportfolio()
 235         mock_get.assert_called_once_with()
 236
 237         portfolio.Portfolio.data["portfolio_1"]["holding"]["direction"][3] = "short"
 238         self.assertRaises(AssertionError, portfolio.Portfolio.parse_cryptoportfolio)
 239
 240     @mock.patch.object(portfolio.Portfolio, "get_cryptoportfolio")
 241     def test_repartition_pertenthousand(self, mock_get):
 242         mock_get.side_effect = self.fill_data
 243
 244         expected_medium = {'USDT': 1000, 'ETC': 1000, 'FCT': 1000, 'OMG': 1000, 'STEEM': 1000, 'STRAT': 1000, 'XEM': 1000, 'XMR': 1000, 'XVC': 1000, 'ZRX': 1000}
 245         expected_high = {'USDT': 1226, 'BTC': 1429, 'ETC': 1127, 'ETH': 1569, 'FCT': 3341, 'GAS': 1308}
 246
 247         self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand())
 248         self.assertEqual(expected_medium, portfolio.Portfolio.repartition_pertenthousand(liquidity="medium"))
 249         self.assertEqual(expected_high, portfolio.Portfolio.repartition_pertenthousand(liquidity="high"))
 250
 251     def tearDown(self):
 252         self.patcher.stop()
 253
 254 if __name__ == '__main__':
 255     unittest.main()