418 lines
15 KiB
Python
418 lines
15 KiB
Python
"""test_reports_related_postings - Unit tests for RelatedPostings"""
|
|
# 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 datetime
|
|
import itertools
|
|
|
|
from decimal import Decimal
|
|
|
|
import pytest
|
|
|
|
from . import testutil
|
|
|
|
from conservancy_beancount import data
|
|
from conservancy_beancount.reports import core
|
|
|
|
def accruals_and_payments(acct, src_acct, dst_acct, start_date, *amounts):
|
|
dates = testutil.date_seq(start_date)
|
|
for amt, currency in amounts:
|
|
post_meta = {'metanumber': amt, 'metacurrency': currency}
|
|
yield testutil.Transaction(date=next(dates), postings=[
|
|
(acct, amt, currency, post_meta),
|
|
(dst_acct if amt < 0 else src_acct, -amt, currency, post_meta),
|
|
])
|
|
|
|
@pytest.fixture
|
|
def credit_card_cycle():
|
|
return list(accruals_and_payments(
|
|
'Liabilities:CreditCard',
|
|
'Assets:Checking',
|
|
'Expenses:Other',
|
|
datetime.date(2020, 4, 1),
|
|
(-110, 'USD'),
|
|
(110, 'USD'),
|
|
(-120, 'USD'),
|
|
(120, 'USD'),
|
|
))
|
|
|
|
@pytest.fixture
|
|
def two_accruals_three_payments():
|
|
return list(accruals_and_payments(
|
|
'Assets:Receivable:Accounts',
|
|
'Income:Donations',
|
|
'Assets:Checking',
|
|
datetime.date(2020, 4, 10),
|
|
(440, 'USD'),
|
|
(-230, 'USD'),
|
|
(550, 'EUR'),
|
|
(-210, 'USD'),
|
|
(-550, 'EUR'),
|
|
))
|
|
|
|
@pytest.fixture
|
|
def link_swap_posts():
|
|
retval = []
|
|
meta = {
|
|
'rt-id': 'rt:12 rt:16',
|
|
'_post_type': data.Posting,
|
|
'_meta_type': data.Metadata,
|
|
}
|
|
for n in range(1, 3):
|
|
n = Decimal(n)
|
|
retval.append(testutil.Posting(
|
|
'Assets:Receivable:Accounts', n * 10, metanum=n, **meta,
|
|
))
|
|
meta['rt-id'] = 'rt:16 rt:12'
|
|
for n in range(1, 3):
|
|
n = Decimal(n)
|
|
retval.append(testutil.Posting(
|
|
'Liabilities:Payable:Accounts', n * -10, metanum=n, **meta,
|
|
))
|
|
return retval
|
|
|
|
def test_initialize_with_list(credit_card_cycle):
|
|
related = core.RelatedPostings(credit_card_cycle[0].postings)
|
|
assert len(related) == 2
|
|
|
|
def test_initialize_with_iterable(two_accruals_three_payments):
|
|
related = core.RelatedPostings(
|
|
post for txn in two_accruals_three_payments
|
|
for post in txn.postings
|
|
if post.account == 'Assets:Receivable:Accounts'
|
|
)
|
|
assert len(related) == 5
|
|
|
|
def test_balance_empty():
|
|
balance = core.RelatedPostings().balance()
|
|
assert not balance
|
|
assert balance.is_zero()
|
|
|
|
@pytest.mark.parametrize('index,expected', enumerate([
|
|
-110,
|
|
0,
|
|
-120,
|
|
0,
|
|
]))
|
|
def test_balance_credit_card(credit_card_cycle, index, expected):
|
|
related = core.RelatedPostings(
|
|
txn.postings[0] for txn in credit_card_cycle[:index + 1]
|
|
)
|
|
assert related.balance() == {'USD': testutil.Amount(expected, 'USD')}
|
|
|
|
def check_iter_with_balance(entries):
|
|
expect_posts = [txn.postings[0] for txn in entries]
|
|
expect_balances = []
|
|
balance_tally = collections.defaultdict(Decimal)
|
|
for post in expect_posts:
|
|
number, currency = post.units
|
|
balance_tally[currency] += number
|
|
expect_balances.append({code: testutil.Amount(number, code)
|
|
for code, number in balance_tally.items()})
|
|
related = core.RelatedPostings(expect_posts)
|
|
for (post, balance), exp_post, exp_balance in zip(
|
|
related.iter_with_balance(),
|
|
expect_posts,
|
|
expect_balances,
|
|
):
|
|
assert post is exp_post
|
|
assert balance == exp_balance
|
|
assert post is expect_posts[-1]
|
|
assert related.balance() == expect_balances[-1]
|
|
|
|
def test_iter_with_balance_empty():
|
|
assert not list(core.RelatedPostings().iter_with_balance())
|
|
|
|
def test_iter_with_balance_credit_card(credit_card_cycle):
|
|
check_iter_with_balance(credit_card_cycle)
|
|
|
|
def test_iter_with_balance_two_acccruals(two_accruals_three_payments):
|
|
check_iter_with_balance(two_accruals_three_payments)
|
|
|
|
def test_balance_at_cost_mixed():
|
|
txn = testutil.Transaction(postings=[
|
|
('Expenses:Other', '22'),
|
|
('Expenses:Other', '30', 'EUR', ('1.1',)),
|
|
('Expenses:Other', '40', 'EUR'),
|
|
('Expenses:Other', '50', 'USD', ('1.1', 'EUR')),
|
|
])
|
|
related = core.RelatedPostings(data.Posting.from_txn(txn))
|
|
balance = related.balance_at_cost()
|
|
amounts = set(balance.values())
|
|
assert amounts == {testutil.Amount(55, 'USD'), testutil.Amount(95, 'EUR')}
|
|
|
|
def test_balance_at_single_currency_cost():
|
|
txn = testutil.Transaction(postings=[
|
|
('Expenses:Other', '22'),
|
|
('Expenses:Other', '30', 'EUR', ('1.1',)),
|
|
('Expenses:Other', '40', 'GBP', ('1.1',)),
|
|
])
|
|
related = core.RelatedPostings(data.Posting.from_txn(txn))
|
|
balance = related.balance_at_cost()
|
|
amounts = set(balance.values())
|
|
assert amounts == {testutil.Amount(99)}
|
|
|
|
def test_balance_at_cost_zeroed_out():
|
|
txn = testutil.Transaction(postings=[
|
|
('Income:Other', '-22'),
|
|
('Assets:Receivable:Accounts', '20', 'EUR', ('1.1',)),
|
|
])
|
|
related = core.RelatedPostings(data.Posting.from_txn(txn))
|
|
balance = related.balance_at_cost()
|
|
assert balance.is_zero()
|
|
|
|
def test_balance_at_cost_singleton():
|
|
txn = testutil.Transaction(postings=[
|
|
('Assets:Receivable:Accounts', '20', 'EUR', ('1.1',)),
|
|
])
|
|
related = core.RelatedPostings(data.Posting.from_txn(txn))
|
|
balance = related.balance_at_cost()
|
|
amounts = set(balance.values())
|
|
assert amounts == {testutil.Amount(22)}
|
|
|
|
def test_balance_at_cost_singleton_without_cost():
|
|
txn = testutil.Transaction(postings=[
|
|
('Assets:Receivable:Accounts', '20'),
|
|
])
|
|
related = core.RelatedPostings(data.Posting.from_txn(txn))
|
|
balance = related.balance_at_cost()
|
|
amounts = set(balance.values())
|
|
assert amounts == {testutil.Amount(20)}
|
|
|
|
def test_balance_at_cost_empty():
|
|
related = core.RelatedPostings()
|
|
balance = related.balance_at_cost()
|
|
assert balance.is_zero()
|
|
|
|
@pytest.mark.parametrize('date,expected', [
|
|
(testutil.FY_MID_DATE - datetime.timedelta(days=1), 0),
|
|
(testutil.FY_MID_DATE, 0),
|
|
(testutil.FY_MID_DATE + datetime.timedelta(days=1), 25),
|
|
(testutil.FY_MID_DATE + datetime.timedelta(days=2), 70),
|
|
(testutil.FY_MID_DATE + datetime.timedelta(days=3), 135),
|
|
(testutil.FY_MID_DATE + datetime.timedelta(days=4), 135),
|
|
])
|
|
def test_balance_at_cost_by_date(date, expected):
|
|
dates = testutil.date_seq()
|
|
jpy_cost = ('0.01', 'USD')
|
|
entries = [
|
|
testutil.Transaction(date=next(dates), postings=[
|
|
('Assets:Cash', 1000, 'JPY', jpy_cost),
|
|
('Assets:Cash', 15),
|
|
]),
|
|
testutil.Transaction(date=next(dates), postings=[
|
|
('Assets:Cash', 2000, 'JPY', jpy_cost),
|
|
('Assets:Cash', 25),
|
|
]),
|
|
testutil.Transaction(date=next(dates), postings=[
|
|
('Assets:Cash', 3000, 'JPY', jpy_cost),
|
|
('Assets:Cash', 35),
|
|
]),
|
|
]
|
|
related = core.RelatedPostings(data.Posting.from_entries(entries))
|
|
actual = related.balance_at_cost_by_date(date)
|
|
if not expected:
|
|
assert actual.is_zero()
|
|
else:
|
|
assert actual == {'USD': testutil.Amount(expected)}
|
|
|
|
def test_meta_values_empty():
|
|
related = core.RelatedPostings()
|
|
assert related.meta_values('key') == set()
|
|
|
|
def test_meta_values_no_match():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, metakey='metavalue'),
|
|
])
|
|
assert related.meta_values('key') == {None}
|
|
|
|
def test_meta_values_no_match_default_given():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, metakey='metavalue'),
|
|
])
|
|
assert related.meta_values('key', '') == {''}
|
|
|
|
def test_meta_values_one_match():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, key='metavalue'),
|
|
])
|
|
assert related.meta_values('key') == {'metavalue'}
|
|
|
|
def test_meta_values_some_match():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, key='1'),
|
|
testutil.Posting('Income:Donations', -2, metakey='2'),
|
|
])
|
|
assert related.meta_values('key') == {'1', None}
|
|
|
|
def test_meta_values_some_match_default_given():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, key='1'),
|
|
testutil.Posting('Income:Donations', -2, metakey='2'),
|
|
])
|
|
assert related.meta_values('key', '') == {'1', ''}
|
|
|
|
def test_meta_values_all_match():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, key='1'),
|
|
testutil.Posting('Income:Donations', -2, key='2'),
|
|
])
|
|
assert related.meta_values('key') == {'1', '2'}
|
|
|
|
def test_meta_values_all_match_one_value():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, key='1'),
|
|
testutil.Posting('Income:Donations', -2, key='1'),
|
|
])
|
|
assert related.meta_values('key') == {'1'}
|
|
|
|
def test_meta_values_all_match_default_given():
|
|
related = core.RelatedPostings([
|
|
testutil.Posting('Income:Donations', -1, key='1'),
|
|
testutil.Posting('Income:Donations', -2, key='2'),
|
|
])
|
|
assert related.meta_values('key', '') == {'1', '2'}
|
|
|
|
def test_meta_values_many_types():
|
|
expected = {
|
|
datetime.date(2020, 4, 1),
|
|
Decimal(42),
|
|
testutil.Amount(5),
|
|
'rt:42',
|
|
}
|
|
related = core.RelatedPostings(
|
|
testutil.Posting('Income:Donations', -index, key=value)
|
|
for index, value in enumerate(expected)
|
|
)
|
|
assert related.meta_values('key') == expected
|
|
|
|
@pytest.mark.parametrize('count', range(3))
|
|
def test_all_meta_links_zero(count):
|
|
related = core.RelatedPostings(testutil.Posting(
|
|
'Income:Donations', -n, testkey=str(n), _meta_type=data.Metadata,
|
|
) for n in range(count))
|
|
assert next(related.all_meta_links('approval'), None) is None
|
|
|
|
def test_all_meta_links_singletons():
|
|
related = core.RelatedPostings(testutil.Posting(
|
|
'Income:Donations', -10, statement=value, _meta_type=data.Metadata,
|
|
) for value in itertools.chain(
|
|
testutil.NON_LINK_METADATA_STRINGS,
|
|
testutil.LINK_METADATA_STRINGS,
|
|
testutil.NON_STRING_METADATA_VALUES,
|
|
))
|
|
assert set(related.all_meta_links('statement')) == testutil.LINK_METADATA_STRINGS
|
|
|
|
def test_all_meta_links_multiples():
|
|
related = core.RelatedPostings(testutil.Posting(
|
|
'Income:Donations', -10, approval=' '.join(value), _meta_type=data.Metadata,
|
|
) for value in itertools.permutations(testutil.LINK_METADATA_STRINGS, 2))
|
|
assert set(related.all_meta_links('approval')) == testutil.LINK_METADATA_STRINGS
|
|
|
|
def test_all_meta_links_preserves_order():
|
|
related = core.RelatedPostings(testutil.Posting(
|
|
'Income:Donations', -10, approval=c, _meta_type=data.Metadata,
|
|
) for c in '121323')
|
|
assert list(related.all_meta_links('approval')) == list('123')
|
|
|
|
def test_first_meta_links():
|
|
related = core.RelatedPostings(testutil.Posting(
|
|
'Assets:Cash', 10, contract=value, _meta_type=data.Metadata,
|
|
) for value in ['1 2', '', '1 3', testutil.PAST_DATE, '2 3', None])
|
|
del related[-1].meta['contract']
|
|
assert list(related.first_meta_links('contract')) == list('12')
|
|
|
|
def test_first_meta_links_fallback():
|
|
related = core.RelatedPostings(testutil.Posting(
|
|
'Assets:Cash', 10, contract=value, _meta_type=data.Metadata,
|
|
) for value in ['1 2', testutil.PAST_DATE, '1 3', None, '2 3'])
|
|
del related[-2].meta['contract']
|
|
assert list(related.first_meta_links('contract', None)) == ['1', None, '2']
|
|
|
|
def test_group_by_meta_zero():
|
|
assert not list(core.RelatedPostings.group_by_meta([], 'metacurrency'))
|
|
|
|
def test_group_by_meta_one(credit_card_cycle):
|
|
posting = next(post for post in data.Posting.from_entries(credit_card_cycle)
|
|
if post.account.is_credit_card())
|
|
actual = core.RelatedPostings.group_by_meta([posting], 'metacurrency')
|
|
assert set(key for key, _ in actual) == {'USD'}
|
|
|
|
def test_group_by_meta_many(two_accruals_three_payments):
|
|
postings = [post for post in data.Posting.from_entries(two_accruals_three_payments)
|
|
if post.account == 'Assets:Receivable:Accounts']
|
|
actual = dict(core.RelatedPostings.group_by_meta(postings, 'metacurrency'))
|
|
assert set(actual) == {'USD', 'EUR'}
|
|
for key, group in actual.items():
|
|
assert 2 <= len(group) <= 3
|
|
assert group.balance().is_zero()
|
|
|
|
def test_group_by_meta_many_single_posts(two_accruals_three_payments):
|
|
postings = [post for post in data.Posting.from_entries(two_accruals_three_payments)
|
|
if post.account == 'Assets:Receivable:Accounts']
|
|
actual = dict(core.RelatedPostings.group_by_meta(postings, 'metanumber'))
|
|
assert set(actual) == {post.units.number for post in postings}
|
|
assert len(actual) == len(postings)
|
|
|
|
def test_group_by_first_meta_link_zero():
|
|
assert not list(core.RelatedPostings.group_by_first_meta_link([], 'foo'))
|
|
|
|
def test_group_by_first_meta_link_no_key(link_swap_posts):
|
|
actual = dict(core.RelatedPostings.group_by_first_meta_link(
|
|
iter(link_swap_posts), 'Nonexistent',
|
|
))
|
|
assert len(actual) == 1
|
|
assert list(actual[None]) == link_swap_posts
|
|
|
|
def test_group_by_first_meta_link_bad_type(link_swap_posts):
|
|
assert all(post.meta.get('metanum') for post in link_swap_posts), \
|
|
"did not find metadata required by test"
|
|
actual = dict(core.RelatedPostings.group_by_first_meta_link(
|
|
iter(link_swap_posts), 'metanum',
|
|
))
|
|
assert len(actual) == 1
|
|
assert list(actual[None]) == link_swap_posts
|
|
|
|
def test_group_by_first_meta_link(link_swap_posts):
|
|
actual_all = dict(core.RelatedPostings.group_by_first_meta_link(
|
|
iter(link_swap_posts), 'rt-id',
|
|
))
|
|
assert len(actual_all) == 2
|
|
for key, expect_account in [
|
|
('rt:12', 'Assets:Receivable:Accounts'),
|
|
('rt:16', 'Liabilities:Payable:Accounts'),
|
|
]:
|
|
actual = actual_all.get(key, '')
|
|
assert len(actual) == 2
|
|
assert all(post.account == expect_account for post in actual)
|
|
|
|
def test_group_by_account():
|
|
entries = [
|
|
testutil.Transaction(postings=[
|
|
('Income:Donations', -10),
|
|
('Assets:Cash', 10),
|
|
]),
|
|
testutil.Transaction(postings=[
|
|
('Income:Donations', -20),
|
|
('Assets:Cash', 20),
|
|
]),
|
|
]
|
|
postings = data.Posting.from_entries(entries)
|
|
actual = dict(core.RelatedPostings.group_by_account(postings))
|
|
assert len(actual) == 2
|
|
for key, related in actual.items():
|
|
assert len(related) == 2
|
|
assert all(post.account == key for post in related)
|