Exemple #1
0
def test_floor_dividing_money_by_int_or_decimal_should_work_with_proper_rounding(
        to_type, dividends_amount, divisor, expected_amount,
        precision):  # noqa: E501
    dividend = Money(dividends_amount, 'EUR', precision)
    expected_quotient = Money(expected_amount, 'EUR', precision)

    assert dividend // to_type(divisor) == expected_quotient
Exemple #2
0
def test_multiplying_with_factors_of_money_and_not_int_or_decimal_should_not_work(
        other):  # noqa: E501
    with pytest.raises(TypeError):
        Money(1, 'USD') * other

    with pytest.raises(TypeError):
        other * Money(1, 'USD')
Exemple #3
0
def test_money_comparison_operators_should_fail_between_money_instances_of_different_currencies(
        operator):  # noqa: E501
    money1 = Money(1, 'EUR')
    money2 = Money(1, 'USD')

    with pytest.raises(IncompatibleCurrencyError):
        operator(money1, money2)
Exemple #4
0
def test_multiplying_with_factors_of_money_and_int_or_decimal_should_work(
        to_type, money_amount, multiplier, expected_amount):  # noqa: E501
    money_factor = Money(money_amount, 'EUR')
    other_factor = to_type(multiplier)
    expected_money = Money(expected_amount, 'EUR')

    assert money_factor * other_factor == expected_money
    assert other_factor * money_factor == expected_money
Exemple #5
0
def test_money_comparison_operators_should_not_fail_between_money_instances_of_the_same_currency(
        operator):  # noqa: E501
    money1 = Money(1, 'EUR')
    money2 = Money(1, 'EUR')

    try:
        operator(money1, money2)
    except IncompatibleCurrencyError as e:
        pytest.fail(str(e))
Exemple #6
0
def test_money_hash__two_identical_instances_of_money_should_have_the_same_hash(
        amount, currency):  # noqa: E501
    instance1 = Money(amount=amount, currency=currency)
    instance2 = Money(amount=amount, currency=currency)

    assert hash(instance1) == hash(instance2)

    # checking hashing invariant
    assert instance1 == instance2
Exemple #7
0
def test_money_subtract_should_not_work_with_instances_of_other_types(
        non_money_object):
    money = Money('10', 'USD')
    with pytest.raises(TypeError):
        money - non_money_object

    with pytest.raises(TypeError):
        non_money_object - money
Exemple #8
0
def test_money_add_should_not_work_with_instances_of_other_types(
        non_money_object):
    money = Money('10', 'EUR')
    with pytest.raises(TypeError):
        money + non_money_object

    with pytest.raises(TypeError):
        non_money_object + money
Exemple #9
0
def test_money_pos():
    assert +Money(1, 'PLN').amount == Decimal('1')
    assert +Money(-1, 'PLN').amount == Decimal('-1')
    assert +Money(0, 'PLN').amount == Decimal('0')
Exemple #10
0
def test_ge(amount1, amount2):
    assert amount1 >= amount2
    assert Money(amount1, 'DKK') >= Money(amount2, 'DKK')
    # double-check the inverse relation with the same data
    assert not (Money(amount1, 'DKK') < Money(amount2, 'DKK'))
Exemple #11
0
def test_gt(amount1, amount2, precision):
    assert amount1 > amount2
    assert Money(amount1, 'DKK', precision) > Money(amount2, 'DKK', precision)
    # double-check the inverse relation with the same data
    assert not (Money(amount1, 'DKK', precision) <= Money(
        amount2, 'DKK', precision))
Exemple #12
0
def test_lte(amount1, amount2):
    assert amount1 <= amount2
    assert Money(amount1, 'CHF') <= Money(amount2, 'CHF')
    # double-check the inverse relation with the same data
    assert not (Money(amount1, 'CHF') > Money(amount2, 'CHF'))
Exemple #13
0
def test_lt(amount1, amount2, precision):
    assert amount1 < amount2
    assert Money(amount1, 'CHF', precision) < Money(amount2, 'CHF', precision)
    # double-check the inverse relation with the same data
    assert not (Money(amount1, 'CHF', precision) >= Money(
        amount2, 'CHF', precision))
Exemple #14
0
def test_currency_code_validation_should_raise_error_on_non_string(
        non_string_object):
    with pytest.raises(TypeError):
        Money(amount=1, currency=non_string_object)
Exemple #15
0
def test_money_amount_round(amount, precision, expected_amount):
    money = Money(amount, 'GBP', precision)
    assert money.amount == expected_amount
Exemple #16
0
def test_money_add_should_work_between_money_instances_of_the_same_currency(
        amount1, amount2, expected):  # noqa: E501
    money1 = Money(amount1, 'EUR')
    money2 = Money(amount2, 'EUR')
    assert (money1 + money2).amount == expected
Exemple #17
0
def test_money_true_and_floor_dividing_should_not_work_with_instances_of_other_types_than_int_and_decimal(
        operation, other):  # noqa: E501
    with pytest.raises(TypeError):
        operation(Money(1, 'USD'), other)
Exemple #18
0
def test_money_bool(amount, expected):
    assert bool(Money(amount=amount, currency='XYZ')) == expected
Exemple #19
0
def test_true_dividing_int_or_decimal_by_money_should_work_with_proper_rounding(
        to_type, dividend, divisors_amount, expected_amount):  # noqa: E501
    divisor = Money(divisors_amount, 'EUR')
    expected_quotient = Money(expected_amount, 'EUR')

    assert to_type(dividend) / divisor == expected_quotient
Exemple #20
0
def test_multiplying_with_factors_of_money_and_decimal_should_work_with_proper_rounding(
        money_amount, multiplier, expected_amount, precision):  # noqa: E501
    assert (Money(money_amount, 'GBP', precision) * multiplier == Money(
        expected_amount, 'GBP', precision))
    assert (multiplier * Money(money_amount, 'GBP', precision) == Money(
        expected_amount, 'GBP', precision))
Exemple #21
0
def test_money_add_should_not_work_between_money_instances_of_different_currencies(
):
    money1 = Money('10', 'EUR')
    money2 = Money('20', 'USD')
    with pytest.raises(IncompatibleCurrencyError):
        money1 + money2
Exemple #22
0
def test_money_comparison_operators_should_fail_with_instances_of_other_types(
        non_money_object, operator):  # noqa: E501
    money = Money('10', 'USD')

    with pytest.raises(TypeError):
        operator(money, non_money_object)
Exemple #23
0
def test_money_properties(amount, currency, expected_amount):
    money = Money(amount, currency)
    assert money.amount == expected_amount
    assert money.currency == currency
Exemple #24
0
def test_eq(amount):
    assert Money(amount, 'CHF') == Money(amount, 'CHF')
Exemple #25
0
def test_money_str(amount, currency, expected):
    assert str(Money(amount, currency)) == expected
Exemple #26
0
def test_ne(amount1, amount2, precision):
    assert amount1 != amount2
    assert Money(amount1, 'CHF', precision) != Money(amount2, 'CHF', precision)
Exemple #27
0
def test_currency_code_validation_should_raise_error_on_malformatted_code(
        bad_code):
    with pytest.raises(MalformattedCurrencyCodeError):
        Money(amount=1, currency=bad_code)
Exemple #28
0
    (999, 'USD'),
    (42, 'EUR'),
])
def test_money_hash__two_identical_instances_of_money_should_have_the_same_hash(
        amount, currency):  # noqa: E501
    instance1 = Money(amount=amount, currency=currency)
    instance2 = Money(amount=amount, currency=currency)

    assert hash(instance1) == hash(instance2)

    # checking hashing invariant
    assert instance1 == instance2


@pytest.mark.parametrize('money1, money2', [
    (Money('10', 'ABC'), Money('10', 'ABX')),
    (Money('10.0000', 'GBP', '.0000'), Money('10.0001', 'GBP', '.0000')),
    (Money('10', 'GBP'), Money('-10', 'GBP')),
])
def test_money_hash__two_different_instances_of_money_should_have_different_hashes(
        money1, money2):  # noqa: E501
    assert (hash(money1) != hash(money2))


# ================================= TEST UNARY OPERATORS =================================


def test_money_neg():
    assert -Money(1, 'PLN').amount == Decimal('-1')
    assert -Money(-1, 'PLN').amount == Decimal('1')
    assert -Money(0, 'PLN').amount == Decimal('0')