File diff 069939b2d3a5 → 3d704e2865fe
tests/test_reports_balance.py
➞
Show inline comments
...
 
@@ -34,6 +34,10 @@ DEFAULT_STRINGS = [
 
    ({'JPY': '-5500.00', 'BRL': '-8500.00'}, "-8,500.00 BRL, -5,500 JPY"),
 
]
 

			




	
	
	
		
 
def amounts_from_map(currency_map):


			




	
	
	
		
 
    for code, number in currency_map.items():


			




	
	
	
		
 
        yield testutil.Amount(number, code)


			




	
	
	
		
 

			




	
	
	
		
 
def test_empty_balance():


			




	
	
	
		
 
    balance = core.Balance()


			




	
	
	
		
 
    assert not balance


			




	...
	
		
 
@@ -49,7 +53,7 @@ def test_empty_balance():


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_zero_balance(currencies):


			




	
	
	
		
 
    keys = currencies.split()


			




	
	
	
		
 
    balance = core.Balance(testutil.balance_map((key, 0) for key in keys))


			




	
	
	
		
 
    balance = core.Balance(testutil.Amount(0, key) for key in keys)


			




	
	
	
		
 
    assert balance


			




	
	
	
		
 
    assert len(balance) == len(keys)


			




	
	
	
		
 
    assert balance.is_zero()


			




	...
	
		
 
@@ -62,22 +66,22 @@ def test_zero_balance(currencies):


			




	
	
	
		
 
    'JPY INR BRL',


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_nonzero_balance(currencies):


			




	
	
	
		
 
    amounts = testutil.balance_map(zip(currencies.split(), itertools.count(110, 100)))


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
    amounts = dict(zip(currencies.split(), itertools.count(110, 100)))


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(amounts))


			




	
	
	
		
 
    assert balance


			




	
	
	
		
 
    assert len(balance) == len(amounts)


			




	
	
	
		
 
    assert not balance.is_zero()


			




	
	
	
		
 
    assert all(balance[key] == amt for key, amt in amounts.items())


			




	
	
	
		
 
    assert all(balance[key] == testutil.Amount(amt, key) for key, amt in amounts.items())


			




	
	
	
		
 

			




	
	
	
		
 
def test_mixed_balance():


			




	
	
	
		
 
    amounts = testutil.balance_map(USD=0, EUR=120)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
    amounts = {'USD': 0, 'EUR': 120}


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(amounts))


			




	
	
	
		
 
    assert balance


			




	
	
	
		
 
    assert len(balance) == 2


			




	
	
	
		
 
    assert not balance.is_zero()


			




	
	
	
		
 
    assert all(balance[key] == amt for key, amt in amounts.items())


			




	
	
	
		
 
    assert all(balance[key] == testutil.Amount(amt, key) for key, amt in amounts.items())


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', [


			




	
	
	
		
 
    ({}, True),


			




	
	
	
		
 
    ({'USD': 0}, True),


			




	
	
	
		
 
    ({'USD': 0, 'EUR': 0}, True),


			




	...
	
		
 
@@ -89,13 +93,12 @@ def test_mixed_balance():


			




	
	
	
		
 
    ({'JPY': 10, 'BRL': 0}, False),


			




	
	
	
		
 
    ({'JPY': 10, 'BRL': 20}, False),


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_eq_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
def test_eq_zero(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.eq_zero() == expected


			




	
	
	
		
 
    assert balance.is_zero() == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', [


			




	
	
	
		
 
    ({}, True),


			




	
	
	
		
 
    ({'USD': 0}, True),


			




	
	
	
		
 
    ({'USD': 0, 'EUR': 0}, True),


			




	...
	
		
 
@@ -106,12 +109,11 @@ def test_eq_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    ({'JPY': 10, 'BRL': 0}, True),


			




	
	
	
		
 
    ({'JPY': 10, 'BRL': 20}, True),


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_ge_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
def test_ge_zero(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.ge_zero() == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', [


			




	
	
	
		
 
    ({}, True),


			




	
	
	
		
 
    ({'USD': 0}, True),


			




	
	
	
		
 
    ({'USD': 0, 'EUR': 0}, True),


			




	...
	
		
 
@@ -122,12 +124,11 @@ def test_ge_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    ({'JPY': 10, 'BRL': 0}, False),


			




	
	
	
		
 
    ({'JPY': 10, 'BRL': 20}, False),


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_le_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts.items())


			




	
	
	
		
 
def test_le_zero(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.le_zero() == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	
	
	
		
 
    {'USD': 0},


			




	
	
	
		
 
    {'EUR': 10},


			




	...
	
		
 
@@ -136,17 +137,13 @@ def test_le_zero(balance_map_kwargs, expected):


			




	
	
	
		
 
    {'JPY': -25, 'BRL': -35},


			




	
	
	
		
 
    {'JPY': 40, 'USD': 0, 'EUR': -50},


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_abs(balance_map_kwargs):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    actual = abs(core.Balance(amounts.items()))


			




	
	
	
		
 
    assert set(actual) == set(balance_map_kwargs)


			




	
	
	
		
 
    abs_amounts = testutil.balance_map(**{


			




	
	
	
		
 
        key: abs(number) for key, number in balance_map_kwargs.items()


			




	
	
	
		
 
    })


			




	
	
	
		
 
    for key in balance_map_kwargs:


			




	
	
	
		
 
        assert actual[key] == abs_amounts[key]


			




	
	
	
		
 
def test_abs(mapping):


			




	
	
	
		
 
    actual = abs(core.Balance(amounts_from_map(mapping)))


			




	
	
	
		
 
    assert set(actual) == set(mapping)


			




	
	
	
		
 
    for key, number in mapping.items():


			




	
	
	
		
 
        assert actual[key] == testutil.Amount(abs(number), key)


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	
	
	
		
 
    {'USD': 0},


			




	
	
	
		
 
    {'EUR': 10},


			




	...
	
		
 
@@ -155,14 +152,13 @@ def test_abs(balance_map_kwargs):


			




	
	
	
		
 
    {'JPY': -25, 'BRL': -35},


			




	
	
	
		
 
    {'JPY': 40, 'USD': 0, 'EUR': -50},


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_neg(balance_map_kwargs):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    actual = -core.Balance(amounts.items())


			




	
	
	
		
 
    assert set(actual) == set(balance_map_kwargs)


			




	
	
	
		
 
    for key in balance_map_kwargs:


			




	
	
	
		
 
        assert actual[key] == -amounts[key]


			




	
	
	
		
 
def test_neg(mapping):


			




	
	
	
		
 
    actual = -core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert set(actual) == set(mapping)


			




	
	
	
		
 
    for key, number in mapping.items():


			




	
	
	
		
 
        assert actual[key] == testutil.Amount(-number, key)


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('kwargs1,kwargs2,expected', [


			




	
	
	
		
 
@pytest.mark.parametrize('map1,map2,expected', [


			




	
	
	
		
 
    ({}, {}, True),


			




	
	
	
		
 
    ({}, {'USD': 0}, True),


			




	
	
	
		
 
    ({}, {'EUR': 1}, False),


			




	...
	
		
 
@@ -173,9 +169,9 @@ def test_neg(balance_map_kwargs):


			




	
	
	
		
 
    ({'USD': 1, 'EUR': 2, 'BRL': '3.0'}, {'USD': '1.0', 'EUR': '2.0'}, False),


			




	
	
	
		
 
    ({'USD': 1, 'EUR': 2}, {'USD': '1.0', 'EUR': '2.0'}, True),


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_eq(kwargs1, kwargs2, expected):


			




	
	
	
		
 
    bal1 = core.Balance(testutil.balance_map(**kwargs1))


			




	
	
	
		
 
    bal2 = core.Balance(testutil.balance_map(**kwargs2))


			




	
	
	
		
 
def test_eq(map1, map2, expected):


			




	
	
	
		
 
    bal1 = core.Balance(amounts_from_map(map1))


			




	
	
	
		
 
    bal2 = core.Balance(amounts_from_map(map2))


			




	
	
	
		
 
    actual = bal1 == bal2


			




	
	
	
		
 
    assert actual == expected


			




	
	
	
		
 

			




	...
	
		
 
@@ -186,8 +182,8 @@ def test_eq(kwargs1, kwargs2, expected):


			




	
	
	
		
 
    (-4000, 'BRL'),


			




	
	
	
		
 
})


			




	
	
	
		
 
def test_add_amount(number, currency):


			




	
	
	
		
 
    start_amounts = testutil.balance_map(USD=500)


			




	
	
	
		
 
    start_bal = core.Balance(start_amounts)


			




	
	
	
		
 
    start_amount = testutil.Amount(500, 'USD')


			




	
	
	
		
 
    start_bal = core.Balance([start_amount])


			




	
	
	
		
 
    add_amount = testutil.Amount(number, currency)


			




	
	
	
		
 
    actual = start_bal + add_amount


			




	
	
	
		
 
    if currency == 'USD':


			




	...
	
		
 
@@ -195,9 +191,9 @@ def test_add_amount(number, currency):


			




	
	
	
		
 
        assert actual['USD'] == testutil.Amount(500 + number)


			




	
	
	
		
 
    else:


			




	
	
	
		
 
        assert len(actual) == 2


			




	
	
	
		
 
        assert actual['USD'] == testutil.Amount(500)


			




	
	
	
		
 
        assert actual['USD'] == start_amount


			




	
	
	
		
 
        assert actual[currency] == add_amount


			




	
	
	
		
 
    assert start_bal == start_amounts


			




	
	
	
		
 
    assert start_bal == {'USD': start_amount}


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('number,currency', {


			




	
	
	
		
 
    (50, 'USD'),


			




	...
	
		
 
@@ -206,8 +202,7 @@ def test_add_amount(number, currency):


			




	
	
	
		
 
    (-4000, 'BRL'),


			




	
	
	
		
 
})


			




	
	
	
		
 
def test_iadd_amount(number, currency):


			




	
	
	
		
 
    start_amounts = testutil.balance_map(USD=500)


			




	
	
	
		
 
    balance = core.MutableBalance(start_amounts)


			




	
	
	
		
 
    balance = core.MutableBalance([testutil.Amount(500, 'USD')])


			




	
	
	
		
 
    add_amount = testutil.Amount(number, currency)


			




	
	
	
		
 
    balance += add_amount


			




	
	
	
		
 
    if currency == 'USD':


			




	...
	
		
 
@@ -218,7 +213,7 @@ def test_iadd_amount(number, currency):


			




	
	
	
		
 
        assert balance['USD'] == testutil.Amount(500)


			




	
	
	
		
 
        assert balance[currency] == add_amount


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	
	
	
		
 
    {'USD': 0},


			




	
	
	
		
 
    {'EUR': 10},


			




	...
	
		
 
@@ -227,18 +222,17 @@ def test_iadd_amount(number, currency):


			




	
	
	
		
 
    {'JPY': -25, 'BRL': -35},


			




	
	
	
		
 
    {'JPY': 40, 'USD': 0, 'EUR': -50},


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_add_balance(balance_map_kwargs):


			




	
	
	
		
 
    start_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    start_bal = core.Balance(testutil.balance_map(**start_numbers))


			




	
	
	
		
 
    expect_numbers = start_numbers.copy()


			




	
	
	
		
 
    for code, number in balance_map_kwargs.items():


			




	
	
	
		
 
def test_add_balance(mapping):


			




	
	
	
		
 
    expect_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    start_bal = core.Balance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    for code, number in mapping.items():


			




	
	
	
		
 
        expect_numbers[code] = expect_numbers.get(code, 0) + number


			




	
	
	
		
 
    add_bal = core.Balance(testutil.balance_map(**balance_map_kwargs))


			




	
	
	
		
 
    add_bal = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    actual = start_bal + add_bal


			




	
	
	
		
 
    expected = core.Balance(testutil.balance_map(**expect_numbers))


			




	
	
	
		
 
    expected = core.Balance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    assert actual == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs', [


			




	
	
	
		
 
@pytest.mark.parametrize('mapping', [


			




	
	
	
		
 
    {},


			




	
	
	
		
 
    {'USD': 0},


			




	
	
	
		
 
    {'EUR': 10},


			




	...
	
		
 
@@ -247,25 +241,24 @@ def test_add_balance(balance_map_kwargs):


			




	
	
	
		
 
    {'JPY': -25, 'BRL': -35},


			




	
	
	
		
 
    {'JPY': 40, 'USD': 0, 'EUR': -50},


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_iadd_balance(balance_map_kwargs):


			




	
	
	
		
 
    start_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    balance = core.MutableBalance(testutil.balance_map(**start_numbers))


			




	
	
	
		
 
    expect_numbers = start_numbers.copy()


			




	
	
	
		
 
    for code, number in balance_map_kwargs.items():


			




	
	
	
		
 
def test_iadd_balance(mapping):


			




	
	
	
		
 
    expect_numbers = {'USD': 500, 'BRL': 40000}


			




	
	
	
		
 
    balance = core.MutableBalance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    for code, number in mapping.items():


			




	
	
	
		
 
        expect_numbers[code] = expect_numbers.get(code, 0) + number


			




	
	
	
		
 
    balance += core.Balance(testutil.balance_map(**balance_map_kwargs))


			




	
	
	
		
 
    expected = core.Balance(testutil.balance_map(**expect_numbers))


			




	
	
	
		
 
    balance += core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    expected = core.Balance(amounts_from_map(expect_numbers))


			




	
	
	
		
 
    assert balance == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('balance_map_kwargs,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_str(balance_map_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**balance_map_kwargs)


			




	
	
	
		
 
    assert str(core.Balance(amounts.items())) == expected


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_str(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert str(balance) == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('bal_kwargs,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_format_defaults(bal_kwargs, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(**bal_kwargs)


			




	
	
	
		
 
    assert core.Balance(amounts).format() == expected


			




	
	
	
		
 
@pytest.mark.parametrize('mapping,expected', DEFAULT_STRINGS)


			




	
	
	
		
 
def test_format_defaults(mapping, expected):


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.format() == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('fmt,expected', [


			




	
	
	
		
 
    ('¤##0.0', '¥5000, -€1500.00'),


			




	...
	
		
 
@@ -274,7 +267,7 @@ def test_format_defaults(bal_kwargs, expected):


			




	
	
	
		
 
    ('#,#00.0 ¤¤;(#,#00.0 ¤¤)', '5,000 JPY, (1,500.00 EUR)'),


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_format_fmt(fmt, expected):


			




	
	
	
		
 
    amounts = testutil.balance_map(JPY=5000, EUR=-1500)


			




	
	
	
		
 
    amounts = [testutil.Amount(5000, 'JPY'), testutil.Amount(-1500, 'EUR')]


			




	
	
	
		
 
    balance = core.Balance(amounts)


			




	
	
	
		
 
    assert balance.format(fmt) == expected


			




	
	
	
		
 

			




	...
	
		
 
@@ -284,16 +277,15 @@ def test_format_fmt(fmt, expected):


			




	
	
	
		
 
    '\0',


			




	
	
	
		
 
])


			




	
	
	
		
 
def test_format_sep(sep):


			




	
	
	
		
 
    bal_kwargs, expected = DEFAULT_STRINGS[-1]


			




	
	
	
		
 
    mapping, expected = DEFAULT_STRINGS[-1]


			




	
	
	
		
 
    expected = expected.replace(', ', sep)


			




	
	
	
		
 
    amounts = testutil.balance_map(**bal_kwargs)


			




	
	
	
		
 
    balance = core.Balance(amounts)


			




	
	
	
		
 
    balance = core.Balance(amounts_from_map(mapping))


			




	
	
	
		
 
    assert balance.format(sep=sep) == expected


			




	
	
	
		
 

			




	
	
	
		
 
def test_format_none():


			




	
	
	
		
 
    amounts = testutil.balance_map(BRL=65000)


			




	
	
	
		
 
    balance = core.Balance(amounts)


			




	
	
	
		
 
    expected = babel.numbers.format_currency(65000, 'BRL')


			




	
	
	
		
 
    args = (65000, 'BRL')


			




	
	
	
		
 
    balance = core.Balance([testutil.Amount(*args)])


			




	
	
	
		
 
    expected = babel.numbers.format_currency(*args)


			




	
	
	
		
 
    assert balance.format(None) == expected


			




	
	
	
		
 

			




	
	
	
		
 
@pytest.mark.parametrize('empty', [


			




        

    



    




    








    
        Server instance: kapok.sfconservancy.org-3352
    
    
        This site is powered by
            Kallithea 0.6.3,
        which is
        © 2010–2020 by various authors & licensed under GPLv3.
            – Support
        – Privacy Policy