"""core.py - Common data classes for reporting functionality"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import collections

import operator

from decimal import Decimal

from .. import data

from typing import (

    overload,

    Callable,

    DefaultDict,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    Optional,

    Sequence,

    Set,

    Tuple,

    Union,

)

from ..beancount_types import (

    MetaKey,

    MetaValue,

)

DecimalCompat = data.DecimalCompat

class Balance(Mapping[str, data.Amount]):

    """A collection of amounts mapped by currency

    Each key is a Beancount currency string, and each value represents the

    balance in that currency.

    """

    __slots__ = ('_currency_map',)

    def __init__(self,

                 source: Union[Iterable[Tuple[str, data.Amount]],

                               Mapping[str, data.Amount]]=(),

    ) -> None:

        if isinstance(source, Mapping):

            source = source.items()

        self._currency_map = {

            currency: amount.number for currency, amount in source

        }

    def __repr__(self) -> str:

        return f"{type(self).__name__}({self._currency_map!r})"

    def __str__(self) -> str:

    def __eq__(self, other: Any) -> bool:

        if (self.is_zero()

            and isinstance(other, Balance)

            and other.is_zero()):

            return True

        else:

            return super().__eq__(other)

    def __neg__(self) -> 'Balance':

        return type(self)(

            (key, -amt) for key, amt in self.items()

        )

    def __getitem__(self, key: str) -> data.Amount:

        return data.Amount(self._currency_map[key], key)

    def __iter__(self) -> Iterator[str]:

        return iter(self._currency_map)

    def __len__(self) -> int:

        return len(self._currency_map)

    def _all_amounts(self,

                     op_func: Callable[[DecimalCompat, DecimalCompat], bool],

                     operand: DecimalCompat,

    ) -> bool:

        return all(op_func(number, operand) for number in self._currency_map.values())

    def eq_zero(self) -> bool:

        """Returns true if all amounts in the balance == 0."""

        return self._all_amounts(operator.eq, 0)

    is_zero = eq_zero

    def ge_zero(self) -> bool:

        """Returns true if all amounts in the balance >= 0."""

        return self._all_amounts(operator.ge, 0)

    def le_zero(self) -> bool:

        """Returns true if all amounts in the balance <= 0."""

        return self._all_amounts(operator.le, 0)

class MutableBalance(Balance):

    __slots__ = ()

    def add_amount(self, amount: data.Amount) -> None:

        try:

            self._currency_map[amount.currency] += amount.number

        except KeyError:

            self._currency_map[amount.currency] = amount.number

class RelatedPostings(Sequence[data.Posting]):

    """Collect and query related postings

    This class provides common functionality for collecting related postings

    and running queries on them: iterating over them, tallying their balance,

    etc.

    This class doesn't know anything about how the postings are related. That's

    entirely up to the caller.

    A common pattern is to use this class with collections.defaultdict

    to organize postings based on some key. See the group_by_meta classmethod

    for an example.

    """

    def __init__(self, source: Iterable[data.Posting]=()) -> None:

        self._postings: List[data.Posting] = list(source)

    @classmethod

    def group_by_meta(cls,

                      postings: Iterable[data.Posting],

                      key: MetaKey,

                      default: Optional[MetaValue]=None,

    ) -> Mapping[Optional[MetaValue], 'RelatedPostings']:

        """Relate postings by metadata value

        This method takes an iterable of postings and returns a mapping.

        The keys of the mapping are the values of post.meta.get(key, default).

        The values are RelatedPostings instances that contain all the postings

        that had that same metadata value.

        """

        retval: DefaultDict[Optional[MetaValue], 'RelatedPostings'] = collections.defaultdict(cls)

        for post in postings:

            retval[post.meta.get(key, default)].add(post)

        retval.default_factory = None

        return retval

    @overload

    def __getitem__(self, index: int) -> data.Posting: ...

    @overload

    def __getitem__(self, s: slice) -> Sequence[data.Posting]: ...

    def __getitem__(self,

                    index: Union[int, slice],

    ) -> Union[data.Posting, Sequence[data.Posting]]:

        if isinstance(index, slice):

            raise NotImplementedError("RelatedPostings[slice]")

        else:

            return self._postings[index]

    def __len__(self) -> int:

        return len(self._postings)

    def add(self, post: data.Posting) -> None:

        self._postings.append(post)

    def all_meta_links(self, key: MetaKey) -> Set[str]:

        retval: Set[str] = set()

        for post in self:

            try:

                retval.update(post.meta.get_links(key))

            except TypeError:

                pass

        return retval

    def clear(self) -> None:

        self._postings.clear()

    def iter_with_balance(self) -> Iterator[Tuple[data.Posting, Balance]]:

        balance = MutableBalance()

        for post in self:

            balance.add_amount(post.units)

            yield post, balance

    def balance(self) -> Balance:

        for _, balance in self.iter_with_balance():

            pass

        try:

            return balance

        except NameError:

            return Balance()

    def balance_at_cost(self) -> Balance:

        balance = MutableBalance()

        for post in self:

            if post.cost is None:

                balance.add_amount(post.units)

            else:

                number = post.units.number * post.cost.number

                balance.add_amount(data.Amount(number, post.cost.currency))

        return balance

    def meta_values(self,

                    key: MetaKey,

                    default: Optional[MetaValue]=None,

    ) -> Set[Optional[MetaValue]]:

        return {post.meta.get(key, default) for post in self}

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    version='1.0.6',

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'beancount>=2.2',  # Debian:beancount

        'PyYAML>=3.0',  # Debian:python3-yaml

        'regex',  # Debian:python3-regex

        'rt>=2.0',

    ],

    setup_requires=[

        'pytest-mypy',

        'pytest-runner',  # Debian:python3-pytest-runner

    ],

    tests_require=[

        'mypy>=0.770',  # Debian:python3-mypy

        'pytest',  # Debian:python3-pytest

    ],

    packages=[

        'conservancy_beancount',

        'conservancy_beancount.plugin',

        'conservancy_beancount.reports',

    ],

    entry_points={

        'console_scripts': [

            'accrual-report = conservancy_beancount.reports.accrual:main',

        ],

    },

)

            ('440', 'invoice feb.csv', 'text/csv', '40.4k'),

        ],

        '490': [],

        '505': [],

        '510': [

            ('4000', 'contract.pdf', 'application/pdf', '1.4m'),

            ('5100', 'invoice april.pdf', 'application/pdf', '1.5m'),

            ('5105', 'payment.png', 'image/png', '51.5k'),

            ('6100', 'invoice may.pdf', 'application/pdf', '1.6m'),

        ],

        '515': [],

    }

@pytest.fixture

def accrual_entries():

    return copy.deepcopy(_accruals_load[0])

@pytest.fixture

def accrual_postings():

    entries = copy.deepcopy(_accruals_load[0])

    return data.Posting.from_entries(entries)

def check_link_regexp(regexp, match_s, first_link_only=False):

    assert regexp

    assert re.search(regexp, match_s)

    assert re.search(regexp, match_s + ' postlink')

    assert re.search(regexp, match_s + '0') is None

    assert re.search(regexp, '1' + match_s) is None

    end_match = re.search(regexp, 'prelink ' + match_s)

    if first_link_only:

        assert end_match is None

    else:

        assert end_match

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

    '{}',

    'rt:{}',

    'rt://ticket/{}',

])

def test_search_term_parse_rt_shortcuts(link_fmt):

    key, regexp = accrual.SearchTerm.parse(link_fmt.format(220))

    assert key == 'rt-id'

    check_link_regexp(regexp, 'rt:220', first_link_only=True)

    check_link_regexp(regexp, 'rt://ticket/220', first_link_only=True)

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

    '{}/{}',

    'rt:{}/{}',

    'rt://ticket/{}/attachments/{}',

])

def test_search_term_parse_invoice_shortcuts(link_fmt):

    key, regexp = accrual.SearchTerm.parse(link_fmt.format(330, 660))

    assert key == 'invoice'

    check_link_regexp(regexp, 'rt:330/660')

    check_link_regexp(regexp, 'rt://ticket/330/attachments/660')

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

    'approval',

    'contract',

    'invoice',

])

def test_search_term_parse_metadata_rt_shortcut(key):

    actual_key, regexp = accrual.SearchTerm.parse(f'{key}=440/420')

    assert actual_key == key

    check_link_regexp(regexp, 'rt:440/420')

    check_link_regexp(regexp, 'rt://ticket/440/attachments/420')

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

    None,

    'approval',

    'contract',

    'invoice',

])

def test_search_term_parse_repo_link(key):

    document = '1234.pdf'

    if key is None:

        key = 'invoice'

        search = document

    else:

        search = f'{key}={document}'

    actual_key, regexp = accrual.SearchTerm.parse(search)

    assert actual_key == key

    check_link_regexp(regexp, document)

@pytest.mark.parametrize('search,unmatched', [

    ('1234.pdf', '1234_pdf'),

])

def test_search_term_parse_regexp_escaping(search, unmatched):

    _, regexp = accrual.SearchTerm.parse(search)

    assert re.search(regexp, unmatched) is None

@pytest.mark.parametrize('search_terms,expect_count,check_func', [

    ([], ACCRUALS_COUNT, lambda post: post.account.is_under(

        'Assets:Receivable:', 'Liabilities:Payable:',

    )),

    ([('invoice', '^rt:505/5050$')], 2, lambda post: post.meta['entity'] == 'DonorA'),

    ([('rt-id', r'^rt:\D+515$')], 1, lambda post: post.meta['entity'] == 'DonorB'),

    ([('entity', '^Lawyer$')], 3, lambda post: post.meta['rt-id'] == 'rt:510'),

    ([('entity', '^Lawyer$'), ('contract', '^rt:510/')], 2,

     lambda post: post.meta['invoice'].startswith('rt:510/')),

    ([('rt-id', '^rt:510$'), ('approval', '.')], 0, lambda post: False),

])

def test_filter_search(accrual_postings, search_terms, expect_count, check_func):

    actual = list(accrual.filter_search(accrual_postings, search_terms))

    if expect_count < ACCRUALS_COUNT:

        assert ACCRUALS_COUNT > len(actual) >= expect_count

    else:

        assert len(actual) == ACCRUALS_COUNT

    for post in actual:

        assert check_func(post)

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

    ('balance', accrual.balance_report),

    ('outgoing', accrual.outgoing_report),

    ('bal', accrual.balance_report),

    ('out', accrual.outgoing_report),

    ('outgoings', accrual.outgoing_report),

])

def test_report_type_by_name(arg, expected):

    assert accrual.ReportType.by_name(arg.lower()) is expected

    assert accrual.ReportType.by_name(arg.title()) is expected

    assert accrual.ReportType.by_name(arg.upper()) is expected

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

    'unknown',

    'blance',

    'outgong',

])

def test_report_type_by_unknown_name(arg):

    # Raising ValueError helps argparse generate good messages.

    with pytest.raises(ValueError):

        accrual.ReportType.by_name(arg)

@pytest.mark.parametrize('meta_key,account', testutil.combine_values(

    CONSISTENT_METADATA,

    ACCOUNTS,

))

def test_consistency_check_when_consistent(meta_key, account):

    invoice = f'test-{meta_key}-invoice'

    meta = {

        'invoice': invoice,

        meta_key: f'test-{meta_key}-value',

    }

    txn = testutil.Transaction(postings=[

        (account, 100, meta),

        (account, -100, meta),

    ])

    related = core.RelatedPostings(data.Posting.from_txn(txn))

    assert not list(accrual.consistency_check({invoice: related}))

@pytest.mark.parametrize('meta_key,account', testutil.combine_values(

    ['approval', 'fx-rate', 'statement'],

    ACCOUNTS,

))

def test_consistency_check_ignored_metadata(meta_key, account):

    invoice = f'test-{meta_key}-invoice'

    txn = testutil.Transaction(postings=[

        (account, 100, {'invoice': invoice, meta_key: 'credit'}),

        (account, -100, {'invoice': invoice, meta_key: 'debit'}),

    ])

    related = core.RelatedPostings(data.Posting.from_txn(txn))

    assert not list(accrual.consistency_check({invoice: related}))

@pytest.mark.parametrize('meta_key,account', testutil.combine_values(

    CONSISTENT_METADATA,

    ACCOUNTS,

))

def test_consistency_check_when_inconsistent(meta_key, account):

    invoice = f'test-{meta_key}-invoice'

    txn = testutil.Transaction(postings=[

        (account, 100, {'invoice': invoice, meta_key: 'credit', 'lineno': 1}),

        (account, -100, {'invoice': invoice, meta_key: 'debit', 'lineno': 2}),

    ])

    related = core.RelatedPostings(data.Posting.from_txn(txn))

    errors = list(accrual.consistency_check({invoice: related}))

    for exp_lineno, (actual, exp_msg) in enumerate(itertools.zip_longest(errors, [

            f'inconsistent {meta_key} for invoice {invoice}: credit',

            f'inconsistent {meta_key} for invoice {invoice}: debit',

    ]), 1):

        assert actual.message == exp_msg

        assert actual.entry is txn

        assert actual.source.get('lineno') == exp_lineno

def check_output(output, expect_patterns):

    output.seek(0)

    testutil.check_lines_match(iter(output), expect_patterns)

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

    ('rt:505/5050', "Zero balance outstanding since 2020-05-05"),

    ('rt:510/5100', "Zero balance outstanding since 2020-05-10"),

    ('rt:510/6100', "-280.00 USD outstanding since 2020-06-10"),

])

def test_balance_report(accrual_postings, invoice, expected):

    related = core.RelatedPostings(

        post for post in accrual_postings

        if post.meta.get('invoice') == invoice

        and post.account.is_under('Assets:Receivable', 'Liabilities:Payable')

    )

    output = io.StringIO()

    accrual.balance_report({invoice: related}, output)

    check_output(output, [invoice, expected])

def test_outgoing_report(accrual_postings):

    invoice = 'rt:510/6100'

    related = core.RelatedPostings(

        post for post in accrual_postings

        if post.meta.get('invoice') == invoice

        and post.account.is_under('Assets:Receivable', 'Liabilities:Payable')

    )

    output = io.StringIO()

    errors = io.StringIO()

    rt_client = RTClient()

    rt_cache = rtutil.RT(rt_client)

    accrual.outgoing_report({invoice: related}, output, errors, rt_client, rt_cache)

    assert not errors.getvalue()

    rt_url = rt_client.DEFAULT_URL[:-9]

    rt_id_url = rf'\b{re.escape(f"{rt_url}Ticket/Display.html?id=510")}\b'

    contract_url = rf'\b{re.escape(f"{rt_url}Ticket/Attachment/4000/4000/contract.pdf")}\b'

    print(output.getvalue())

    check_output(output, [

        r'^PAYMENT FOR APPROVAL:$',

        r'^REQUESTOR: Mx\. 510 <mx510@example\.org>$',

        r'^TOTAL TO PAY: 280\.00 USD$',

        fr'^AGREEMENT: {contract_url}',

        r'^PAYMENT TO: Hon\. Mx\. 510$',

        r'^PAYMENT METHOD: payment method 510$',

        r'^BEANCOUNT ENTRIES:$',

        # For each transaction, check for the date line, a metadata, and the

        # Expenses posting.

        r'^\s*2020-06-10\s',

        fr'^\s+rt-id: "{rt_id_url}"$',

        r'^\s+Expenses:Services:Legal\s+220\.00 USD$',

        r'^\s*2020-06-12\s',

        fr'^\s+contract: "{contract_url}"$',

        r'^\s+Expenses:FilingFees\s+60\.00 USD$',

    ])

def test_outgoing_report_custom_field_fallbacks(accrual_postings):

    invoice = 'rt:510/6100'

    related = core.RelatedPostings(

        post for post in accrual_postings

        if post.meta.get('invoice') == invoice

        and post.account.is_under('Assets:Receivable', 'Liabilities:Payable')

    )

    output = io.StringIO()

    errors = io.StringIO()

    rt_client = RTClient(want_cfs=False)

    rt_cache = rtutil.RT(rt_client)

    accrual.outgoing_report({invoice: related}, output, errors, rt_client, rt_cache)

    assert not errors.getvalue()

    check_output(output, [

        r'^PAYMENT FOR APPROVAL:$',

        r'^REQUESTOR: <mx510@example\.org>$',

        r'^PAYMENT TO:\s*$',

        r'^PAYMENT METHOD:\s*$',

    ])

def run_main(arglist, config=None):

    if config is None:

        config = testutil.TestConfig(

            books_path=testutil.test_path('books/accruals.beancount'),

            rt_client=RTClient(),

        )

    output = io.StringIO()

    errors = io.StringIO()

    retcode = accrual.main(arglist, output, errors, config)

    return retcode, output, errors

def check_main_fails(arglist, config, error_flags, error_patterns):

    retcode, output, errors = run_main(arglist, config)

    assert retcode > 16

    assert (retcode - 16) & error_flags

    check_output(errors, error_patterns)

    assert not output.getvalue()

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

    ['--report-type=balance'],

    ['--report-type=outgoing'],

    ['entity=EarlyBird'],

])

def test_output_excludes_payments(arglist):

    retcode, output, errors = run_main(arglist)

    assert not errors.getvalue()

    assert retcode == 0

    output.seek(0)

    for line in output:

        assert not re.match(r'\brt:4\d\b', line)

@pytest.mark.parametrize('arglist,expect_invoice', [

    (['40'], 'rt:40/400'),

    (['44/440'], 'rt:44/440'),

])

def test_output_payments_when_only_match(arglist, expect_invoice):

    retcode, output, errors = run_main(arglist)

    assert not errors.getvalue()

    assert retcode == 0

    check_output(output, [

        rf'^{re.escape(expect_invoice)}:$',

        r' outstanding since ',

    ])

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

    ['--report-type=outgoing'],

    ['510'],

    ['510/6100'],

    ['entity=Lawyer'],

])

def test_main_outgoing_report(arglist):

    retcode, output, errors = run_main(arglist)

    assert not errors.getvalue()

    assert retcode == 0

    rt_url = RTClient.DEFAULT_URL[:-9]

    rt_id_url = re.escape(f'<{rt_url}Ticket/Display.html?id=510>')

    contract_url = re.escape(f'<{rt_url}Ticket/Attachment/4000/4000/contract.pdf>')

    check_output(output, [

        r'^REQUESTOR: Mx\. 510 <mx510@example\.org>$',

        r'^TOTAL TO PAY: 280\.00 USD$',

        r'^\s*2020-06-12\s',

        r'^\s+Expenses:FilingFees\s+60\.00 USD$',

    ])

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

    ['-t', 'balance'],

    ['515'],

    ['515/5150'],

    ['entity=DonorB'],

])

def test_main_balance_report(arglist):

    retcode, output, errors = run_main(arglist)

    assert not errors.getvalue()

    assert retcode == 0

    check_output(output, [

        r'\brt://ticket/515/attachments/5150:$',

    ])

def test_main_no_books():

    check_main_fails([], testutil.TestConfig(), 1 | 8, [

        r':1: +no books to load in configuration\b',

    ])

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

    ['499'],

    ['505/99999'],

    ['entity=NonExistent'],

])

def test_main_no_matches(arglist):

    check_main_fails(arglist, None, 8, [

        r'^warning: no matching entries found to report$',

    ])

def test_main_no_rt():

    config = testutil.TestConfig(

        books_path=testutil.test_path('books/accruals.beancount'),

    )

    check_main_fails(['-t', 'out'], config, 4, [

        r'^error: unable to generate outgoing report: RT client is required\b',

    ])

"""test_reports_balance - Unit tests for reports.core.Balance"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import itertools

from decimal import Decimal

import pytest

from . import testutil

from conservancy_beancount.reports import core

def test_empty_balance():

    balance = core.Balance()

    assert not balance

    assert len(balance) == 0

    assert balance.is_zero()

    with pytest.raises(KeyError):

        balance['USD']

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

    'USD',

    'EUR GBP',

    'JPY INR BRL',

])

def test_zero_balance(currencies):

    keys = currencies.split()

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

    assert balance

    assert len(balance) == len(keys)

    assert balance.is_zero()

    assert all(balance[key].number == 0 for key in keys)

    assert all(balance[key].currency == key for key in keys)

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

    'USD',

    'EUR GBP',

    'JPY INR BRL',

])

def test_nonzero_balance(currencies):

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

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

    assert balance

    assert len(balance) == len(amounts)

    assert not balance.is_zero()

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

def test_mixed_balance():

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

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

    assert balance

    assert len(balance) == 2

    assert not balance.is_zero()

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

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

    ({}, True),

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

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

    ({'USD': -10, 'EUR': 0}, False),

    ({'EUR': -10}, False),

    ({'USD': -10, 'EUR': -20}, False),

    ({'USD': 10, 'EUR': -20}, False),

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

    ({'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())

    assert balance.eq_zero() == expected

    assert balance.is_zero() == expected

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

    ({}, True),

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

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

    ({'EUR': -10}, False),

    ({'USD': 10, 'EUR': -20}, False),

    ({'USD': -10, 'EUR': -20}, False),

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

    ({'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())

    assert balance.ge_zero() == expected

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

    ({}, True),

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

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

    ({'EUR': -10}, True),

    ({'USD': 10, 'EUR': -20}, False),

    ({'USD': -10, 'EUR': -20}, True),

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

    ({'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())

    assert balance.le_zero() == expected

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

    {},

    {'USD': 0},

    {'EUR': 10},

    {'JPY': 20, 'BRL': 30},

    {'EUR': -15},

    {'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]

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

    ({}, {}, True),

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

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

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

    ({'USD': 1}, {'USD': '1.0'}, True),

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

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

    ({'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))

    actual = bal1 == bal2

    assert actual == expected

def test_str(balance_map_kwargs, expected):

    amounts = testutil.balance_map(**balance_map_kwargs)

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