def test_replace():
price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
price3 = Price(Amount(20, 'EUR'), Amount(30, 'EUR'))
price_range = PriceRange(price1, price2)
result = price_range.replace(max_price=price3)
assert result.min_price == price1
assert result.max_price == price3
result = price_range.replace(min_price=price3)
assert result.min_price == price3
assert result.max_price == price2
class PriceRangeTest(unittest.TestCase):
def setUp(self):
self.ten_btc = Price(10, currency='BTC')
self.twenty_btc = Price(20, currency='BTC')
self.thirty_btc = Price(30, currency='BTC')
self.forty_btc = Price(40, currency='BTC')
self.range_ten_twenty = PriceRange(self.ten_btc, self.twenty_btc)
self.range_thirty_forty = PriceRange(self.thirty_btc, self.forty_btc)
def test_basics(self):
self.assertEqual(self.range_ten_twenty.min_price, self.ten_btc)
self.assertEqual(self.range_ten_twenty.max_price, self.twenty_btc)
def test_construction(self):
pr = PriceRange(self.ten_btc)
self.assertEqual(pr.min_price, self.ten_btc)
self.assertEqual(pr.max_price, self.ten_btc)
def test_invalid_construction(self):
p = Price(10, currency='USD')
self.assertRaises(ValueError, lambda: PriceRange(self.ten_btc, p))
self.assertRaises(ValueError,
lambda: PriceRange(self.twenty_btc, self.ten_btc))
def test_addition(self):
pr1 = self.range_ten_twenty + self.range_thirty_forty
self.assertEqual(pr1.min_price, self.ten_btc + self.thirty_btc)
self.assertEqual(pr1.max_price, self.twenty_btc + self.forty_btc)
pr2 = self.range_ten_twenty + self.ten_btc
self.assertEqual(pr2.min_price, self.ten_btc + self.ten_btc)
self.assertEqual(pr2.max_price, self.twenty_btc + self.ten_btc)
def test_invalid_addition(self):
p = Price(10, currency='USD')
pr = PriceRange(p)
self.assertRaises(ValueError, lambda: self.range_ten_twenty + pr)
self.assertRaises(ValueError, lambda: self.range_ten_twenty + p)
self.assertRaises(TypeError, lambda: self.range_ten_twenty + 10)
def test_subtraction(self):
pr1 = self.range_thirty_forty - self.range_ten_twenty
pr2 = self.range_thirty_forty - self.ten_btc
self.assertEqual(pr1.min_price, self.thirty_btc - self.ten_btc)
self.assertEqual(pr1.max_price, self.forty_btc - self.twenty_btc)
self.assertEqual(pr2.min_price, self.thirty_btc - self.ten_btc)
self.assertEqual(pr2.max_price, self.forty_btc - self.ten_btc)
def test_invalid_subtraction(self):
p = Price(10, currency='USD')
pr = PriceRange(p)
self.assertRaises(ValueError, lambda: self.range_thirty_forty - pr)
self.assertRaises(ValueError, lambda: self.range_thirty_forty - p)
self.assertRaises(TypeError, lambda: self.range_thirty_forty - 1)
def test_equality(self):
pr1 = PriceRange(self.ten_btc, self.twenty_btc)
pr2 = PriceRange(self.ten_btc, self.twenty_btc)
pr3 = PriceRange(self.ten_btc, self.ten_btc)
pr4 = PriceRange(self.twenty_btc, self.twenty_btc)
self.assertEqual(pr1, pr2)
self.assertNotEqual(pr1, pr3)
self.assertNotEqual(pr1, pr4)
self.assertNotEqual(pr1, self.ten_btc)
self.assertFalse(pr1 != pr2)
def test_membership(self):
self.assertTrue(self.ten_btc in self.range_ten_twenty)
self.assertTrue(self.twenty_btc in self.range_ten_twenty)
self.assertFalse(self.thirty_btc in self.range_ten_twenty)
def test_invalid_membership(self):
self.assertRaises(TypeError, lambda: 15 in self.range_ten_twenty)
def test_replacement(self):
pr1 = self.range_ten_twenty.replace(max_price=self.thirty_btc)
self.assertEqual(pr1.min_price, self.ten_btc)
self.assertEqual(pr1.max_price, self.thirty_btc)
pr2 = self.range_thirty_forty.replace(min_price=self.twenty_btc)
self.assertEqual(pr2.min_price, self.twenty_btc)
self.assertEqual(pr2.max_price, self.forty_btc)
def test_repr(self):
pr1 = self.range_thirty_forty
pr2 = PriceRange(self.ten_btc, self.ten_btc)
self.assertEqual(
repr(pr1), "PriceRange(Price('30', currency='BTC'),"
" Price('40', currency='BTC'))")
self.assertEqual(repr(pr2), "PriceRange(Price('10', currency='BTC'))")
def test_comparison(self):
p10 = Price(10, currency='USD')
p20 = Price(20, currency='USD')
self.assertTrue(p10 < p20)
self.assertTrue(p20 > p10)
self.assertTrue(p10 <= p10)
self.assertTrue(p10 >= p10)
self.assertTrue(p10 == p10)
class PriceRangeTest(unittest.TestCase):
def setUp(self):
self.ten_btc = Price(10, currency='BTC')
self.twenty_btc = Price(20, currency='BTC')
self.thirty_btc = Price(30, currency='BTC')
self.forty_btc = Price(40, currency='BTC')
self.range_ten_twenty = PriceRange(self.ten_btc, self.twenty_btc)
self.range_thirty_forty = PriceRange(self.thirty_btc, self.forty_btc)
def test_basics(self):
self.assertEqual(self.range_ten_twenty.min_price, self.ten_btc)
self.assertEqual(self.range_ten_twenty.max_price, self.twenty_btc)
def test_construction(self):
pr = PriceRange(self.ten_btc)
self.assertEqual(pr.min_price, self.ten_btc)
self.assertEqual(pr.max_price, self.ten_btc)
def test_invalid_construction(self):
p = Price(10, currency='USD')
self.assertRaises(ValueError, lambda: PriceRange(self.ten_btc, p))
self.assertRaises(ValueError, lambda: PriceRange(self.twenty_btc,
self.ten_btc))
def test_addition(self):
pr1 = self.range_ten_twenty + self.range_thirty_forty
self.assertEqual(pr1.min_price, self.ten_btc + self.thirty_btc)
self.assertEqual(pr1.max_price, self.twenty_btc + self.forty_btc)
pr2 = self.range_ten_twenty + self.ten_btc
self.assertEqual(pr2.min_price, self.ten_btc + self.ten_btc)
self.assertEqual(pr2.max_price, self.twenty_btc + self.ten_btc)
def test_invalid_addition(self):
p = Price(10, currency='USD')
pr = PriceRange(p)
self.assertRaises(ValueError, lambda: self.range_ten_twenty + pr)
self.assertRaises(ValueError, lambda: self.range_ten_twenty + p)
self.assertRaises(TypeError, lambda: self.range_ten_twenty + 10)
def test_subtraction(self):
pr1 = self.range_thirty_forty - self.range_ten_twenty
pr2 = self.range_thirty_forty - self.ten_btc
self.assertEqual(pr1.min_price, self.thirty_btc - self.ten_btc)
self.assertEqual(pr1.max_price, self.forty_btc - self.twenty_btc)
self.assertEqual(pr2.min_price, self.thirty_btc - self.ten_btc)
self.assertEqual(pr2.max_price, self.forty_btc - self.ten_btc)
def test_invalid_subtraction(self):
p = Price(10, currency='USD')
pr = PriceRange(p)
self.assertRaises(ValueError, lambda: self.range_thirty_forty - pr)
self.assertRaises(ValueError, lambda: self.range_thirty_forty - p)
self.assertRaises(TypeError, lambda: self.range_thirty_forty - 1)
def test_equality(self):
pr1 = PriceRange(self.ten_btc, self.twenty_btc)
pr2 = PriceRange(self.ten_btc, self.twenty_btc)
pr3 = PriceRange(self.ten_btc, self.ten_btc)
pr4 = PriceRange(self.twenty_btc, self.twenty_btc)
self.assertEqual(pr1, pr2)
self.assertNotEqual(pr1, pr3)
self.assertNotEqual(pr1, pr4)
self.assertNotEqual(pr1, self.ten_btc)
def test_membership(self):
self.assertTrue(self.ten_btc in self.range_ten_twenty)
self.assertTrue(self.twenty_btc in self.range_ten_twenty)
self.assertFalse(self.thirty_btc in self.range_ten_twenty)
def test_invalid_membership(self):
self.assertRaises(TypeError, lambda: 15 in self.range_ten_twenty)
def test_replacement(self):
pr1 = self.range_ten_twenty.replace(max_price=self.thirty_btc)
self.assertEqual(pr1.min_price, self.ten_btc)
self.assertEqual(pr1.max_price, self.thirty_btc)
pr2 = self.range_thirty_forty.replace(min_price=self.twenty_btc)
self.assertEqual(pr2.min_price, self.twenty_btc)
self.assertEqual(pr2.max_price, self.forty_btc)
def test_repr(self):
pr1 = self.range_thirty_forty
pr2 = PriceRange(self.ten_btc, self.ten_btc)
self.assertEqual(
repr(pr1),
"PriceRange(Price('30', currency='BTC'),"
" Price('40', currency='BTC'))")
self.assertEqual(
repr(pr2),
"PriceRange(Price('10', currency='BTC'))")
class PriceRangeTest(unittest.TestCase):
def setUp(self):
self.ten_btc = Price(10, currency='BTC')
self.twenty_btc = Price(20, currency='BTC')
self.thirty_btc = Price(30, currency='BTC')
self.forty_btc = Price(40, currency='BTC')
self.range_ten_twenty = PriceRange(self.ten_btc, self.twenty_btc)
self.range_thirty_forty = PriceRange(self.thirty_btc, self.forty_btc)
def test_basics(self):
self.assertEqual(self.range_ten_twenty.min_price, self.ten_btc)
self.assertEqual(self.range_ten_twenty.max_price, self.twenty_btc)
def test_valid_addition(self):
pr1 = self.range_ten_twenty + self.range_thirty_forty
self.assertEqual(pr1.min_price, self.ten_btc + self.thirty_btc)
self.assertEqual(pr1.max_price, self.twenty_btc + self.forty_btc)
pr2 = self.range_ten_twenty + self.ten_btc
self.assertEqual(pr2.min_price, self.ten_btc + self.ten_btc)
self.assertEqual(pr2.max_price, self.twenty_btc + self.ten_btc)
def test_invalid_addition(self):
self.assertRaises(TypeError, lambda: self.range_ten_twenty + 10)
def test_subtraction(self):
pr1 = self.range_thirty_forty - self.range_ten_twenty
self.assertEqual(pr1.min_price, self.thirty_btc - self.ten_btc)
self.assertEqual(pr1.max_price, self.forty_btc - self.twenty_btc)
def test_valid_membership(self):
'''
Prices can fit in a pricerange.
'''
self.assertTrue(self.ten_btc in self.range_ten_twenty)
self.assertTrue(self.twenty_btc in self.range_ten_twenty)
self.assertFalse(self.thirty_btc in self.range_ten_twenty)
def test_invalid_membership(self):
'''
Non-prices can't fit in a pricerange.
'''
self.assertRaises(TypeError, lambda: 15 in self.range_ten_twenty)
def test_replacement(self):
pr1 = self.range_ten_twenty.replace(max_price=self.thirty_btc)
self.assertEqual(pr1.min_price, self.ten_btc)
self.assertEqual(pr1.max_price, self.thirty_btc)
pr2 = self.range_thirty_forty.replace(min_price=self.twenty_btc)
self.assertEqual(pr2.min_price, self.twenty_btc)
self.assertEqual(pr2.max_price, self.forty_btc)
def test_tax(self):
tax_name = '2x Tax'
tax = LinearTax(1, name=tax_name)
pr = self.range_ten_twenty + tax
self.assertEqual(pr.min_price.net, self.ten_btc.net)
self.assertEqual(pr.min_price.gross, self.ten_btc.gross * 2)
self.assertEqual(pr.min_price.currency, self.ten_btc.currency)
self.assertEqual(pr.max_price.net, self.twenty_btc.net)
self.assertEqual(pr.max_price.gross, self.twenty_btc.gross * 2)
self.assertEqual(pr.max_price.currency, self.twenty_btc.currency)
