Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 1 | import unittest |
| 2 | |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 3 | from hypothesis import given |
| 4 | from hypothesis import strategies as st |
| 5 | |
Ankush Menat | 9c49d2d | 2022-01-15 12:52:10 +0530 | [diff] [blame^] | 6 | from erpnext.stock.valuation import FIFOValuation, LIFOValuation, _round_off_if_near_zero |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 7 | |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 8 | qty_gen = st.floats(min_value=-1e6, max_value=1e6) |
| 9 | value_gen = st.floats(min_value=1, max_value=1e6) |
| 10 | stock_queue_generator = st.lists(st.tuples(qty_gen, value_gen), min_size=10) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 11 | |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 12 | |
Ankush Menat | 9c49d2d | 2022-01-15 12:52:10 +0530 | [diff] [blame^] | 13 | class TestFIFOValuation(unittest.TestCase): |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 14 | |
| 15 | def setUp(self): |
Ankush Menat | 107b404 | 2021-12-19 20:47:08 +0530 | [diff] [blame] | 16 | self.queue = FIFOValuation([]) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 17 | |
| 18 | def tearDown(self): |
| 19 | qty, value = self.queue.get_total_stock_and_value() |
| 20 | self.assertTotalQty(qty) |
| 21 | self.assertTotalValue(value) |
| 22 | |
| 23 | def assertTotalQty(self, qty): |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 24 | self.assertAlmostEqual(sum(q for q, _ in self.queue), qty, msg=f"queue: {self.queue}", places=4) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 25 | |
| 26 | def assertTotalValue(self, value): |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 27 | self.assertAlmostEqual(sum(q * r for q, r in self.queue), value, msg=f"queue: {self.queue}", places=2) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 28 | |
| 29 | def test_simple_addition(self): |
| 30 | self.queue.add_stock(1, 10) |
| 31 | self.assertTotalQty(1) |
| 32 | |
| 33 | def test_simple_removal(self): |
| 34 | self.queue.add_stock(1, 10) |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 35 | self.queue.remove_stock(1) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 36 | self.assertTotalQty(0) |
| 37 | |
| 38 | def test_merge_new_stock(self): |
| 39 | self.queue.add_stock(1, 10) |
| 40 | self.queue.add_stock(1, 10) |
| 41 | self.assertEqual(self.queue, [[2, 10]]) |
| 42 | |
| 43 | def test_adding_negative_stock_keeps_rate(self): |
Ankush Menat | 107b404 | 2021-12-19 20:47:08 +0530 | [diff] [blame] | 44 | self.queue = FIFOValuation([[-5.0, 100]]) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 45 | self.queue.add_stock(1, 10) |
| 46 | self.assertEqual(self.queue, [[-4, 100]]) |
| 47 | |
| 48 | def test_adding_negative_stock_updates_rate(self): |
Ankush Menat | 107b404 | 2021-12-19 20:47:08 +0530 | [diff] [blame] | 49 | self.queue = FIFOValuation([[-5.0, 100]]) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 50 | self.queue.add_stock(6, 10) |
| 51 | self.assertEqual(self.queue, [[1, 10]]) |
| 52 | |
| 53 | |
| 54 | def test_negative_stock(self): |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 55 | self.queue.remove_stock(1, 5) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 56 | self.assertEqual(self.queue, [[-1, 5]]) |
| 57 | |
| 58 | # XXX |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 59 | self.queue.remove_stock(1, 10) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 60 | self.assertTotalQty(-2) |
| 61 | |
| 62 | self.queue.add_stock(2, 10) |
| 63 | self.assertTotalQty(0) |
| 64 | self.assertTotalValue(0) |
| 65 | |
| 66 | def test_removing_specified_rate(self): |
| 67 | self.queue.add_stock(1, 10) |
| 68 | self.queue.add_stock(1, 20) |
| 69 | |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 70 | self.queue.remove_stock(1, 20) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 71 | self.assertEqual(self.queue, [[1, 10]]) |
| 72 | |
| 73 | |
| 74 | def test_remove_multiple_bins(self): |
| 75 | self.queue.add_stock(1, 10) |
| 76 | self.queue.add_stock(2, 20) |
| 77 | self.queue.add_stock(1, 20) |
| 78 | self.queue.add_stock(5, 20) |
| 79 | |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 80 | self.queue.remove_stock(4) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 81 | self.assertEqual(self.queue, [[5, 20]]) |
| 82 | |
| 83 | |
| 84 | def test_remove_multiple_bins_with_rate(self): |
| 85 | self.queue.add_stock(1, 10) |
| 86 | self.queue.add_stock(2, 20) |
| 87 | self.queue.add_stock(1, 20) |
| 88 | self.queue.add_stock(5, 20) |
| 89 | |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 90 | self.queue.remove_stock(3, 20) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 91 | self.assertEqual(self.queue, [[1, 10], [5, 20]]) |
| 92 | |
| 93 | def test_collapsing_of_queue(self): |
| 94 | self.queue.add_stock(1, 1) |
| 95 | self.queue.add_stock(1, 2) |
| 96 | self.queue.add_stock(1, 3) |
| 97 | self.queue.add_stock(1, 4) |
| 98 | |
| 99 | self.assertTotalValue(10) |
| 100 | |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 101 | self.queue.remove_stock(3, 1) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 102 | # XXX |
| 103 | self.assertEqual(self.queue, [[1, 7]]) |
| 104 | |
| 105 | def test_rounding_off(self): |
| 106 | self.queue.add_stock(1.0, 1.0) |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 107 | self.queue.remove_stock(1.0 - 1e-9) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 108 | self.assertTotalQty(0) |
| 109 | |
| 110 | def test_rounding_off_near_zero(self): |
| 111 | self.assertEqual(_round_off_if_near_zero(0), 0) |
| 112 | self.assertEqual(_round_off_if_near_zero(1), 1) |
| 113 | self.assertEqual(_round_off_if_near_zero(-1), -1) |
| 114 | self.assertEqual(_round_off_if_near_zero(-1e-8), 0) |
| 115 | self.assertEqual(_round_off_if_near_zero(1e-8), 0) |
| 116 | |
| 117 | def test_totals(self): |
| 118 | self.queue.add_stock(1, 10) |
| 119 | self.queue.add_stock(2, 13) |
| 120 | self.queue.add_stock(1, 17) |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 121 | self.queue.remove_stock(1) |
| 122 | self.queue.remove_stock(1) |
| 123 | self.queue.remove_stock(1) |
Ankush Menat | 1833f7a | 2021-12-18 19:37:41 +0530 | [diff] [blame] | 124 | self.queue.add_stock(5, 17) |
| 125 | self.queue.add_stock(8, 11) |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 126 | |
| 127 | @given(stock_queue_generator) |
| 128 | def test_fifo_qty_hypothesis(self, stock_queue): |
Ankush Menat | 107b404 | 2021-12-19 20:47:08 +0530 | [diff] [blame] | 129 | self.queue = FIFOValuation([]) |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 130 | total_qty = 0 |
| 131 | |
| 132 | for qty, rate in stock_queue: |
| 133 | if qty == 0: |
| 134 | continue |
| 135 | if qty > 0: |
| 136 | self.queue.add_stock(qty, rate) |
| 137 | total_qty += qty |
| 138 | else: |
| 139 | qty = abs(qty) |
| 140 | consumed = self.queue.remove_stock(qty) |
| 141 | self.assertAlmostEqual(qty, sum(q for q, _ in consumed), msg=f"incorrect consumption {consumed}") |
| 142 | total_qty -= qty |
| 143 | self.assertTotalQty(total_qty) |
| 144 | |
| 145 | @given(stock_queue_generator) |
| 146 | def test_fifo_qty_value_nonneg_hypothesis(self, stock_queue): |
Ankush Menat | 107b404 | 2021-12-19 20:47:08 +0530 | [diff] [blame] | 147 | self.queue = FIFOValuation([]) |
Ankush Menat | aa0e163 | 2021-12-19 17:02:04 +0530 | [diff] [blame] | 148 | total_qty = 0.0 |
| 149 | total_value = 0.0 |
| 150 | |
| 151 | for qty, rate in stock_queue: |
| 152 | # don't allow negative stock |
| 153 | if qty == 0 or total_qty + qty < 0 or abs(qty) < 0.1: |
| 154 | continue |
| 155 | if qty > 0: |
| 156 | self.queue.add_stock(qty, rate) |
| 157 | total_qty += qty |
| 158 | total_value += qty * rate |
| 159 | else: |
| 160 | qty = abs(qty) |
| 161 | consumed = self.queue.remove_stock(qty) |
| 162 | self.assertAlmostEqual(qty, sum(q for q, _ in consumed), msg=f"incorrect consumption {consumed}") |
| 163 | total_qty -= qty |
| 164 | total_value -= sum(q * r for q, r in consumed) |
| 165 | self.assertTotalQty(total_qty) |
| 166 | self.assertTotalValue(total_value) |
Ankush Menat | 9c49d2d | 2022-01-15 12:52:10 +0530 | [diff] [blame^] | 167 | |
| 168 | |
| 169 | class TestLIFOValuation(unittest.TestCase): |
| 170 | |
| 171 | def setUp(self): |
| 172 | self.stack = LIFOValuation([]) |
| 173 | |
| 174 | def tearDown(self): |
| 175 | qty, value = self.stack.get_total_stock_and_value() |
| 176 | self.assertTotalQty(qty) |
| 177 | self.assertTotalValue(value) |
| 178 | |
| 179 | def assertTotalQty(self, qty): |
| 180 | self.assertAlmostEqual(sum(q for q, _ in self.stack), qty, msg=f"stack: {self.stack}", places=4) |
| 181 | |
| 182 | def assertTotalValue(self, value): |
| 183 | self.assertAlmostEqual(sum(q * r for q, r in self.stack), value, msg=f"stack: {self.stack}", places=2) |
| 184 | |
| 185 | def test_simple_addition(self): |
| 186 | self.stack.add_stock(1, 10) |
| 187 | self.assertTotalQty(1) |
| 188 | |
| 189 | def test_merge_new_stock(self): |
| 190 | self.stack.add_stock(1, 10) |
| 191 | self.stack.add_stock(1, 10) |
| 192 | self.assertEqual(self.stack, [[2, 10]]) |
| 193 | |
| 194 | def test_simple_removal(self): |
| 195 | self.stack.add_stock(1, 10) |
| 196 | self.stack.remove_stock(1) |
| 197 | self.assertTotalQty(0) |
| 198 | |
| 199 | def test_adding_negative_stock_keeps_rate(self): |
| 200 | self.stack = LIFOValuation([[-5.0, 100]]) |
| 201 | self.stack.add_stock(1, 10) |
| 202 | self.assertEqual(self.stack, [[-4, 100]]) |
| 203 | |
| 204 | def test_adding_negative_stock_updates_rate(self): |
| 205 | self.stack = LIFOValuation([[-5.0, 100]]) |
| 206 | self.stack.add_stock(6, 10) |
| 207 | self.assertEqual(self.stack, [[1, 10]]) |
| 208 | |
| 209 | def test_rounding_off(self): |
| 210 | self.stack.add_stock(1.0, 1.0) |
| 211 | self.stack.remove_stock(1.0 - 1e-9) |
| 212 | self.assertTotalQty(0) |
| 213 | |
| 214 | def test_lifo_consumption(self): |
| 215 | self.stack.add_stock(10, 10) |
| 216 | self.stack.add_stock(10, 20) |
| 217 | consumed = self.stack.remove_stock(15) |
| 218 | self.assertEqual(consumed, [[10, 20], [5, 10]]) |
| 219 | self.assertTotalQty(5) |
| 220 | |
| 221 | def test_lifo_consumption_going_negative(self): |
| 222 | self.stack.add_stock(10, 10) |
| 223 | self.stack.add_stock(10, 20) |
| 224 | consumed = self.stack.remove_stock(25) |
| 225 | self.assertEqual(consumed, [[10, 20], [10, 10], [5, 10]]) |
| 226 | self.assertTotalQty(-5) |
| 227 | |
| 228 | def test_lifo_consumption_multiple(self): |
| 229 | self.stack.add_stock(1, 1) |
| 230 | self.stack.add_stock(2, 2) |
| 231 | consumed = self.stack.remove_stock(1) |
| 232 | self.assertEqual(consumed, [[1, 2]]) |
| 233 | |
| 234 | self.stack.add_stock(3, 3) |
| 235 | consumed = self.stack.remove_stock(4) |
| 236 | self.assertEqual(consumed, [[3, 3], [1, 2]]) |
| 237 | |
| 238 | self.stack.add_stock(4, 4) |
| 239 | consumed = self.stack.remove_stock(5) |
| 240 | self.assertEqual(consumed, [[4, 4], [1, 1]]) |
| 241 | |
| 242 | self.stack.add_stock(5, 5) |
| 243 | consumed = self.stack.remove_stock(5) |
| 244 | self.assertEqual(consumed, [[5, 5]]) |
| 245 | |
| 246 | |
| 247 | @given(stock_queue_generator) |
| 248 | def test_lifo_qty_hypothesis(self, stock_stack): |
| 249 | self.stack = LIFOValuation([]) |
| 250 | total_qty = 0 |
| 251 | |
| 252 | for qty, rate in stock_stack: |
| 253 | if qty == 0: |
| 254 | continue |
| 255 | if qty > 0: |
| 256 | self.stack.add_stock(qty, rate) |
| 257 | total_qty += qty |
| 258 | else: |
| 259 | qty = abs(qty) |
| 260 | consumed = self.stack.remove_stock(qty) |
| 261 | self.assertAlmostEqual(qty, sum(q for q, _ in consumed), msg=f"incorrect consumption {consumed}") |
| 262 | total_qty -= qty |
| 263 | self.assertTotalQty(total_qty) |
| 264 | |
| 265 | @given(stock_queue_generator) |
| 266 | def test_lifo_qty_value_nonneg_hypothesis(self, stock_stack): |
| 267 | self.stack = LIFOValuation([]) |
| 268 | total_qty = 0.0 |
| 269 | total_value = 0.0 |
| 270 | |
| 271 | for qty, rate in stock_stack: |
| 272 | # don't allow negative stock |
| 273 | if qty == 0 or total_qty + qty < 0 or abs(qty) < 0.1: |
| 274 | continue |
| 275 | if qty > 0: |
| 276 | self.stack.add_stock(qty, rate) |
| 277 | total_qty += qty |
| 278 | total_value += qty * rate |
| 279 | else: |
| 280 | qty = abs(qty) |
| 281 | consumed = self.stack.remove_stock(qty) |
| 282 | self.assertAlmostEqual(qty, sum(q for q, _ in consumed), msg=f"incorrect consumption {consumed}") |
| 283 | total_qty -= qty |
| 284 | total_value -= sum(q * r for q, r in consumed) |
| 285 | self.assertTotalQty(total_qty) |
| 286 | self.assertTotalValue(total_value) |