Liabilities:Payable) for errors and metadata consistency, and reports any

problems on stderr. Then it writes a report about the status of those

accruals.

If you run it with no arguments, it will generate an aging report in ODS format

in the current directory.

Otherwise, the typical way to run it is to pass an RT ticket number or

invoice link as an argument, to report about accruals that match those

criteria::

    # Report all accruals associated with RT#1230:

    accrual-report 1230

    # Report all accruals with the invoice link rt:45/670.

    accrual-report 45/670

    # Report all accruals with the invoice link Invoice980.pdf.

    accrual-report Invoice980.pdf

By default, to stay fast, accrual-report only looks for postings from the

beginning of the last fiscal year. You can search further back in history

by passing the ``--since`` argument. The argument can be a fiscal year, or

a negative number of how many years back to search::

    # Search for accruals since 2016

    accrual-report --since 2016 [search terms …]

    # Search for accruals from the beginning of three fiscal years ago

    accrual-report --since -3 [search terms …]

If you want to further limit what accruals are reported, you can match on

other metadata by passing additional arguments in ``name=value`` format.

You can pass any number of search terms. For example::

    # Report accruals associated with RT#1230 and Jane Doe

    accrual-report 1230 entity=Doe-Jane

accrual-report will automatically decide what kind of report to generate

from the search terms you provide and the results they return. If you pass

no search terms, it generates an aging report. If your search terms match a

single outstanding payable, it writes an outgoing approval report.

Otherwise, it writes a basic balance report. You can specify what report

type you want with the ``--report-type`` option::

    # Write an outgoing approval report for all outstanding accruals for

    # Jane Doe, even if there's more than one

    accrual-report --report-type outgoing entity=Doe-Jane

    # Write an aging report for a specific project

    accrual-report --report-type aging project=ProjectName

"""

# 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 argparse

import collections

import datetime

import enum

import logging

import re

import sys

import urllib.parse as urlparse

from pathlib import Path

from typing import (

    cast,

    Any,

    BinaryIO,

    Callable,

    Iterable,

    Iterator,

    List,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    Set,

    TextIO,

    Tuple,

    TypeVar,

    Union,

)

from ..beancount_types import (

    Entries,

    Error,

    Errors,

    MetaKey,

    MetaValue,

    Transaction,

)

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

import rt

from beancount.parser import printer as bc_printer

from . import core

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

from .. import filters

from .. import rtutil

PROGNAME = 'accrual-report'

CompoundAmount = TypeVar('CompoundAmount', data.Amount, core.Balance)

PostGroups = Mapping[Optional[MetaValue], 'AccrualPostings']

RTObject = Mapping[str, str]

T = TypeVar('T')

logger = logging.getLogger('conservancy_beancount.reports.accrual')

class Sentinel:

    pass

class Account(NamedTuple):

    name: str

    aging_thresholds: Sequence[int]

class AccrualAccount(enum.Enum):

    # Note the aging report uses the same order accounts are defined here.

    # See AgingODS.start_spreadsheet().

    RECEIVABLE = Account('Assets:Receivable', [365, 120, 90, 60])

    PAYABLE = Account('Liabilities:Payable', [365, 90, 60, 30])

    @classmethod

    def account_names(cls) -> Iterator[str]:

        return (acct.value.name for acct in cls)

    @classmethod

    def by_account(cls, name: data.Account) -> 'AccrualAccount':

        for account in cls:

            if name.is_under(account.value.name):

                return account

        raise ValueError(f"unrecognized account {name!r}")

    @classmethod

    def classify(cls, related: core.RelatedPostings) -> 'AccrualAccount':

        for account in cls:

            account_name = account.value.name

            if all(post.account.is_under(account_name) for post in related):

                return account

        raise ValueError("unrecognized account set in related postings")

    @property

    def normalize_amount(self) -> Callable[[T], T]:

        return core.normalize_amount_func(self.value.name)

class AccrualPostings(core.RelatedPostings):

    __slots__ = (

        'accrual_type',

        'end_balance',

        'account',

        'entity',

        'invoice',

    )

    INCONSISTENT = Sentinel()

    def __init__(self,

                 source: Iterable[data.Posting]=(),

                 *,

                 _can_own: bool=False,

    ) -> None:

        super().__init__(source, _can_own=_can_own)

        # The following type declarations tell mypy about values set in the for

        # loop that are important enough to be referenced directly elsewhere.

        self.account = self._single_item(post.account for post in self)

        if isinstance(self.account, Sentinel):

            self.accrual_type: Optional[AccrualAccount] = None

            norm_func: Callable[[T], T] = lambda x: x

            entity_pred: Callable[[data.Posting], bool] = bool

        else:

            self.accrual_type = AccrualAccount.by_account(self.account)

            norm_func = self.accrual_type.normalize_amount

            entity_pred = lambda post: norm_func(post.units).number > 0

        self.entity = self._single_item(self.entities(entity_pred))

        self.invoice = self._single_item(self.first_meta_links('invoice', None))

        self.end_balance = norm_func(self.balance_at_cost())

    def _single_item(self, seq: Iterable[T]) -> Union[T, Sentinel]:

        items = iter(seq)

        try:

            item1 = next(items)

        except StopIteration:

            all_same = False

        else:

            all_same = all(item == item1 for item in items)

        return item1 if all_same else self.INCONSISTENT

    def entities(self, pred: Callable[[data.Posting], bool]=bool) -> Iterator[MetaValue]:

        return filters.iter_unique(

            post.meta['entity']

            for post in self

            if pred(post) and 'entity' in post.meta

        )

    def make_consistent(self) -> Iterator[Tuple[MetaValue, 'AccrualPostings']]:

        account_ok = isinstance(self.account, str)

        entity_ok = isinstance(self.entity, str)

        # `'/' in self.invoice` is just our heuristic to ensure that the

        # invoice metadata is "unique enough," and not just a placeholder

        # value like "FIXME". It can be refined if needed.

        invoice_ok = isinstance(self.invoice, str) and '/' in self.invoice

        if account_ok and entity_ok and invoice_ok:

            yield (self.invoice, self)

            return

        groups = collections.defaultdict(list)

        for post in self:

            post_invoice = self.invoice if invoice_ok else (

                post.meta.get('invoice') or 'BlankInvoice'

            )

            post_entity = self.entity if entity_ok else (

                post.meta.get('entity') or 'BlankEntity'

            )

            groups[f'{post.account} {post_invoice} {post_entity}'].append(post)

        type_self = type(self)

        for group_key, posts in groups.items():

            yield group_key, type_self(posts, _can_own=True)

    def is_paid(self, default: Optional[bool]=None) -> Optional[bool]:

        if self.accrual_type is None:

            return default

        else:

            return self.end_balance.le_zero()

    def is_zero(self, default: Optional[bool]=None) -> Optional[bool]:

        if self.accrual_type is None:

            return default

        else:

            return self.end_balance.is_zero()

    def since_last_nonzero(self) -> 'AccrualPostings':

        for index, (post, balance) in enumerate(self.iter_with_balance()):

            if balance.is_zero():

                start_index = index

        try:

            empty = start_index == index

        except NameError:

            empty = True

        return self if empty else self[start_index + 1:]

class BaseReport:

    def __init__(self, out_file: TextIO) -> None:

        self.out_file = out_file

        self.logger = logger.getChild(type(self).__name__)

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

        raise NotImplementedError("BaseReport._report")

    def run(self, groups: PostGroups) -> None:

        for index, invoice in enumerate(groups):

            for line in self._report(groups[invoice], index):

                print(line, file=self.out_file)

class AgingODS(core.BaseODS[AccrualPostings, Optional[data.Account]]):

    COLUMNS = [

        'Date',

        'Entity',

        'Invoice Amount',

        'Booked Amount',

        'Project',

        'Ticket',

        'Invoice',

        'Approval',

        'Contract',

        'Purchase Order',

    ]

    COL_COUNT = len(COLUMNS)

    def __init__(self,

                 rt_client: rt.Rt,

                 date: datetime.date,

                 logger: logging.Logger,

    ) -> None:

        super().__init__()

        self.rt_client = rt_client

        self.rt_wrapper = rtutil.RT(self.rt_client)

        self.date = date

        self.logger = logger

    def init_styles(self) -> None:

        super().init_styles()

        self.style_widecol = self.replace_child(

            self.document.automaticstyles,

            odf.style.Style,

            name='WideCol',

        )

        self.style_widecol.setAttribute('family', 'table-column')

        self.style_widecol.addElement(odf.style.TableColumnProperties(

            columnwidth='1.25in',

        ))

    def section_key(self, row: AccrualPostings) -> Optional[data.Account]:

        if isinstance(row.account, str):

            return row.account

        else:

            return None

    def start_spreadsheet(self) -> None:

        for accrual_type in AccrualAccount:

            self.use_sheet(accrual_type.name.title())

            for index in range(self.COL_COUNT):

                stylename = self.style_widecol if index else ''

                self.sheet.addElement(odf.table.TableColumn(stylename=stylename))

            self.add_row(*(

                self.string_cell(name, stylename=self.style_bold)

                for name in self.COLUMNS

            ))

            self.lock_first_row()

    def start_section(self, key: Optional[data.Account]) -> None:

        if key is None:

            return

        self.age_thresholds = list(AccrualAccount.by_account(key).value.aging_thresholds)

        self.age_balances = [core.MutableBalance() for _ in self.age_thresholds]

        accrual_date = self.date - datetime.timedelta(days=self.age_thresholds[-1])

        acct_parts = key.slice_parts()

        self.use_sheet(acct_parts[1])

        self.add_row()

        self.add_row(self.string_cell(

            f"{' '.join(acct_parts[2:])} {acct_parts[1]} Aging Report"

            f" Accrued by {accrual_date.isoformat()} Unpaid by {self.date.isoformat()}",

            stylename=self.merge_styles(self.style_bold, self.style_centertext),

            numbercolumnsspanned=self.COL_COUNT,

        ))

        self.add_row()

    def end_section(self, key: Optional[data.Account]) -> None:

        if key is None:

            return

        total_balance = core.MutableBalance()

        text_style = self.merge_styles(self.style_bold, self.style_endtext)

        text_span = 4

        last_age_text: Optional[str] = None

        self.add_row()

        for threshold, balance in zip(self.age_thresholds, self.age_balances):

            years, days = divmod(threshold, 365)

            years_text = f"{years} {'Year' if years == 1 else 'Years'}"

            days_text = f"{days} Days"

            if years and days:

                age_text = f"{years_text} {days_text}"

            elif years:

                age_text = years_text

            else:

                age_text = days_text

            if last_age_text is None:

                age_range = f"Over {age_text}"

            else:

                age_range = f"{age_text}–{last_age_text}"

            self.add_row(

                self.string_cell(

                    f"Total Aged {age_range}: ",

                    stylename=text_style,

                    numbercolumnsspanned=text_span,

                ),

                *(odf.table.TableCell() for _ in range(1, text_span)),

                self.balance_cell(balance),

            )

            last_age_text = age_text

            total_balance += balance

        self.add_row(

            self.string_cell(

                "Total Unpaid: ",

                stylename=text_style,

                numbercolumnsspanned=text_span,

            ),

            *(odf.table.TableCell() for _ in range(1, text_span)),

            self.balance_cell(total_balance),

        )

    def _link_seq(self, row: AccrualPostings, key: MetaKey) -> Iterator[Tuple[str, str]]:

        for href in row.all_meta_links(key):

            text: Optional[str] = None

            rt_ids = self.rt_wrapper.parse(href)

            if rt_ids is not None:

                ticket_id, attachment_id = rt_ids

                if attachment_id is None:

                    text = f'RT#{ticket_id}'

                href = self.rt_wrapper.url(ticket_id, attachment_id) or href

            else:

                # '..' pops the ODS filename off the link path. In other words,

                # make the link relative to the directory the ODS is in.

                href = f'../{href}'

            if text is None:

                href_path = Path(urlparse.urlparse(href).path)

                text = urlparse.unquote(href_path.name)

            yield (href, text)

    def write_row(self, row: AccrualPostings) -> None:

        age = (self.date - row[0].meta.date).days

        if row.end_balance.ge_zero():

            for index, threshold in enumerate(self.age_thresholds):

                if age >= threshold:

                    self.age_balances[index] += row.end_balance

                    break

            else:

                return

        raw_balance = row.balance()

        if row.accrual_type is not None:

            raw_balance = row.accrual_type.normalize_amount(raw_balance)

        if raw_balance == row.end_balance:

            amount_cell = odf.table.TableCell()

        else:

            amount_cell = self.balance_cell(raw_balance)

        projects = {post.meta.get('project') or None for post in row}

        projects.discard(None)

        self.add_row(

            self.date_cell(row[0].meta.date),

            self.multiline_cell(row.entities()),

            amount_cell,

            self.balance_cell(row.end_balance),

            self.multiline_cell(sorted(projects)),

            self.multilink_cell(self._link_seq(row, 'rt-id')),

            self.multilink_cell(self._link_seq(row, 'invoice')),

            self.multilink_cell(self._link_seq(row, 'approval')),

            self.multilink_cell(self._link_seq(row, 'contract')),

            self.multilink_cell(self._link_seq(row, 'purchase-order')),

        )

class AgingReport(BaseReport):

    def __init__(self,

                 rt_client: rt.Rt,

                 out_file: BinaryIO,

                 date: Optional[datetime.date]=None,

    ) -> None:

        if date is None:

            date = datetime.date.today()

        self.out_bin = out_file

        self.logger = logger.getChild(type(self).__name__)

        self.ods = AgingODS(rt_client, date, self.logger)

    def run(self, groups: PostGroups) -> None:

        rows: List[AccrualPostings] = []

        for group in groups.values():

            if group.is_zero():

                # Cheap optimization: don't slice and dice groups we're not

                # going to report anyway.

                continue

            elif group.accrual_type is None:

                group = group.since_last_nonzero()

            else:

                # Filter out new accruals after the report date.

                # e.g., cover the case that the same invoices has multiple

                # postings over time, and we don't want to report too-recent

                # ones.

                cutoff_date = self.ods.date - datetime.timedelta(

                    days=group.accrual_type.value.aging_thresholds[-1],

                )

                group = AccrualPostings(

                    post for post in group.since_last_nonzero()

                    if post.meta.date <= cutoff_date

                    or group.accrual_type.normalize_amount(post.units.number) < 0

                )

            if group and not group.is_zero():

                rows.append(group)

        rows.sort(key=lambda related: (

            related.account,

            related[0].meta.date,

            ('\0'.join(related.entities())

             if related.entity is related.INCONSISTENT

             else related.entity),

        ))

        self.ods.write(rows)

        self.ods.save_file(self.out_bin)

class BalanceReport(BaseReport):

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

        posts = posts.since_last_nonzero()

        date_s = posts[0].meta.date.strftime('%Y-%m-%d')

        if index:

            yield ""

        yield f"{posts.invoice}:"

        yield f"  {posts.balance_at_cost()} outstanding since {date_s}"

class OutgoingReport(BaseReport):

    def __init__(self, rt_client: rt.Rt, out_file: TextIO) -> None:

        super().__init__(out_file)

        self.rt_client = rt_client

        self.rt_wrapper = rtutil.RT(rt_client)

    def _primary_rt_id(self, posts: AccrualPostings) -> rtutil.TicketAttachmentIds:

        rt_ids = list(posts.first_meta_links('rt-id'))

        rt_ids_count = len(rt_ids)

        if rt_ids_count != 1:

            raise ValueError(f"{rt_ids_count} rt-id links found")

        parsed = rtutil.RT.parse(rt_ids.pop())

        if parsed is None:

            raise ValueError("rt-id is not a valid RT reference")

        else:

            return parsed

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

    if post.account.startswith(('Assets:Receivable:', 'Liabilities:Payable:'))

)

ACCOUNTS = [

    'Assets:Receivable:Accounts',

    'Assets:Receivable:Loans',

    'Liabilities:Payable:Accounts',

    'Liabilities:Payable:Vacation',

]

class AgingRow(NamedTuple):

    date: datetime.date

    entity: Sequence[str]

    amount: Optional[Sequence[bc_data.Amount]]

    at_cost: bc_data.Amount

    rt_id: Sequence[str]

    invoice: Sequence[str]

    project: Sequence[str]

    @classmethod

    def make_simple(cls, date, entity, at_cost, invoice,

                    rt_id=None, orig_amount=None, project='Conservancy'):

        if isinstance(date, str):

            date = datetime.datetime.strptime(date, '%Y-%m-%d').date()

        if not isinstance(at_cost, tuple):

            at_cost = testutil.Amount(at_cost)

        if rt_id is None:

            rt_id, _, _ = invoice.partition('/')

        return cls(date, [entity], orig_amount, at_cost, [rt_id], [invoice], [project])

    def check_row_match(self, sheet_row):

        cells = testutil.ODSCell.from_row(sheet_row)

        assert len(cells) >= len(self)

        cells = iter(cells)

        assert next(cells).value == self.date

        assert next(cells).text == '\0'.join(self.entity)

        assert next(cells).text == '\0'.join(

            babel.numbers.format_currency(number, currency, format_type='accounting')

            for number, currency in self.amount or ()

        )

        usd_cell = next(cells)

        assert usd_cell.value_type == 'currency'

        assert usd_cell.value == self.at_cost.number

        assert next(cells).text == '\0'.join(self.project)

        for index, cell in enumerate(cells):

            links = cell.getElementsByType(odf.text.A)

            assert len(links) == len(cell.childNodes)

        assert index >= 1

AGING_AP = [

    AgingRow.make_simple('2010-03-06', 'EarlyBird', -125, 'rt:44/440'),

    AgingRow.make_simple('2010-03-30', 'EarlyBird', 75, 'rt:490/4900'),

    AgingRow.make_simple('2010-04-30', 'Vendor', 200, 'FIXME'),

    AgingRow.make_simple('2010-06-10', 'Lawyer', 280, 'rt:510/6100'),

    AgingRow.make_simple('2010-06-18', 'EuroGov', 1100, 'rt:520/5200',

                         orig_amount=[testutil.Amount(1000, 'EUR')]),

]

AGING_AR = [

    AgingRow.make_simple('2010-03-05', 'EarlyBird', -500, 'rt:40/400'),

    AgingRow.make_simple('2010-05-15', 'MatchingProgram', 1500,

                         'rt://ticket/515/attachments/5150'),

    AgingRow.make_simple('2010-06-15', 'GrantCo', 11500, 'rt:470/4700',

                         project='Development Grant'),

]

class RTClient(testutil.RTClient):

    TICKET_DATA = {

        '40': [

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

        ],

        '44': [

            ('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': [],

        '520': [],

    }

@pytest.fixture

def accrual_postings():

    return data.Posting.from_entries(copy.deepcopy(ACCRUAL_TXNS))

def accruals_by_meta(postings, value, key='invoice', wrap_type=iter):

    return wrap_type(

        post for post in postings

        if post.meta.get(key) == value

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

    )

def find_row_by_text(row_source, want_text):

    for row in row_source:

        try:

            found_row = row.childNodes[0].text == want_text

        except IndexError:

            found_row = False

        if found_row:

            return row

    return None

def check_aging_sheet(sheet, aging_rows, date, accrue_date):

    if not aging_rows:

        return

    if isinstance(accrue_date, int):

        accrue_date = date + datetime.timedelta(days=accrue_date)

    rows = iter(sheet.getElementsByType(odf.table.TableRow))

    for row in rows:

        if "Aging Report" in row.text:

            break

    else:

        assert None, "Header row not found"

    assert f"Accrued by {accrue_date.isoformat()}" in row.text

    assert f"Unpaid by {date.isoformat()}" in row.text

    expect_rows = iter(aging_rows)

    row0 = find_row_by_text(rows, aging_rows[0].date.isoformat())

    next(expect_rows).check_row_match(row0)

    for actual, expected in zip(rows, expect_rows):

        expected.check_row_match(actual)

    for row in rows:

        if row.text.startswith("Total Aged "):

            break

    else:

        assert None, "Totals rows not found"

    actual_sum = Decimal(row.childNodes[-1].value)

    for row in rows:

        if row.text.startswith("Total Aged "):

            actual_sum += Decimal(row.childNodes[-1].value)

        else:

            break

    assert actual_sum == sum(

        row.at_cost.number

        for row in aging_rows

        if row.date <= accrue_date

        and row.at_cost.number > 0

    )

def check_aging_ods(ods_file,

                    date=None,

                    recv_rows=AGING_AR,

                    pay_rows=AGING_AP,

):

    if date is None:

        date = datetime.date.today()

    ods_file.seek(0)

    ods = odf.opendocument.load(ods_file)

    sheets = ods.spreadsheet.getElementsByType(odf.table.Table)

    assert len(sheets) == 2

    check_aging_sheet(sheets[0], recv_rows, date, -60)

    check_aging_sheet(sheets[1], pay_rows, date, -30)

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

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

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

    )),

    ([('rt-id', '^rt:505$')], 2, lambda post: post.meta['entity'] == 'DonorA'),

    ([('invoice', r'^rt:\D+515/')], 1, lambda post: post.meta['entity'] == 'MatchingProgram'),

    ([('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):

    search_terms = [cliutil.SearchTerm._make(query) for query in search_terms]

    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', [

    ('aging', accrual.AgingReport),

    ('balance', accrual.BalanceReport),

    ('outgoing', accrual.OutgoingReport),

    ('age', accrual.AgingReport),

    ('bal', accrual.BalanceReport),

    ('out', accrual.OutgoingReport),

    ('outgoings', accrual.OutgoingReport),

])

def test_report_type_by_name(arg, expected):

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

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

    assert accrual.ReportType.by_name(arg.upper()).value 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('acct_name', ACCOUNTS)

def test_accrual_postings_consistent_account(acct_name):

    meta = {'invoice': '{acct_name} invoice.pdf'}

    txn = testutil.Transaction(postings=[

        (acct_name, 50, meta),

        (acct_name, 25, meta),

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    assert related.account == acct_name

def test_accrual_postings_entity():

    txn = testutil.Transaction(postings=[

        (ACCOUNTS[0], 25, {'entity': 'Accruee'}),

        (ACCOUNTS[0], -15, {'entity': 'Payee15'}),

        (ACCOUNTS[0], -10, {'entity': 'Payee10'}),

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    assert related.entity == 'Accruee'

    assert set(related.entities()) == {'Accruee', 'Payee10', 'Payee15'}

def test_accrual_postings_entities():

    txn = testutil.Transaction(postings=[

        (ACCOUNTS[0], 25, {'entity': 'Accruee'}),

        (ACCOUNTS[0], -15, {'entity': 'Payee15'}),

        (ACCOUNTS[0], -10, {'entity': 'Payee10'}),

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    actual = related.entities()

    assert next(actual, None) == 'Accruee'

    assert set(actual) == {'Payee10', 'Payee15'}

def test_accrual_postings_entities_no_duplicates():

    txn = testutil.Transaction(postings=[

        (ACCOUNTS[0], 25, {'entity': 'Accruee'}),

        (ACCOUNTS[0], -15, {'entity': 'Accruee'}),

        (ACCOUNTS[0], -10, {'entity': 'Other'}),

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    actual = related.entities()

    assert next(actual, None) == 'Accruee'

    assert next(actual, None) == 'Other'

    assert next(actual, None) is None

def test_accrual_postings_inconsistent_account():

    meta = {'invoice': 'invoice.pdf'}

    txn = testutil.Transaction(postings=[

        (acct_name, index, meta)

        for index, acct_name in enumerate(ACCOUNTS)

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    assert related.account is related.INCONSISTENT

@pytest.mark.parametrize('acct_name,invoice,day', testutil.combine_values(

    ACCOUNTS,

    ['FIXME', '', None, *testutil.NON_STRING_METADATA_VALUES],

    itertools.count(1),

))

def test_make_consistent_bad_invoice(acct_name, invoice, day):

    txn = testutil.Transaction(date=datetime.date(2019, 1, day), postings=[

        (acct_name, index * 10, {'invoice': invoice, 'entity': f'BadInvoice{day}'})

        for index in range(1, 4)

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = dict(related.make_consistent())

    assert len(consistent) == 1

    key = next(iter(consistent))

    assert acct_name in key

    if invoice:

        assert str(invoice) in key

    actual = consistent[key]

    assert actual

    assert len(actual) == 3

    for act_post, exp_post in zip(actual, txn.postings):

        assert act_post.units == exp_post.units

        assert act_post.meta.get('invoice') == invoice

def test_make_consistent_across_accounts():

    invoice = 'Invoices/CrossAccount.pdf'

    txn = testutil.Transaction(date=datetime.date(2019, 2, 1), postings=[

        (acct_name, 100, {'invoice': invoice, 'entity': 'CrossAccount'})

        for acct_name in ACCOUNTS

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = dict(related.make_consistent())

    assert len(consistent) == len(ACCOUNTS)

    for key, posts in consistent.items():

        assert len(posts) == 1

        assert posts.account in key

def test_make_consistent_both_invoice_and_account():

    txn = testutil.Transaction(date=datetime.date(2019, 2, 2), postings=[

        (acct_name, 150) for acct_name in ACCOUNTS

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = dict(related.make_consistent())

    assert len(consistent) == len(ACCOUNTS)

    for key, posts in consistent.items():

        assert len(posts) == 1

        assert posts.account in key

@pytest.mark.parametrize('acct_name', ACCOUNTS)

def test_make_consistent_across_entity(acct_name):

    amt_sign = operator.pos if acct_name.startswith('Assets') else operator.neg

    txn = testutil.Transaction(postings=[

        (acct_name, amt_sign(n), {'invoice': 'Inv/1.pdf', 'entity': f'Entity{n}'})

        for n in range(1, 4)

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = dict(related.make_consistent())

    assert len(consistent) == 3

    for key, posts in consistent.items():

        assert len(posts) == 1

        entities = posts.entities()

        assert next(entities, None) == posts.entity

        assert next(entities, None) is None

        assert posts.entity in key

@pytest.mark.parametrize('acct_name', ACCOUNTS)

def test_make_consistent_entity_differs_accrual_payment(acct_name):

    invoice = 'Invoices/DifferPay.pdf'

    txn = testutil.Transaction(postings=[

        # Depending on the account, the order of the accrual and payment might

        # be swapped here, but that shouldn't matter.

        (acct_name, 125, {'invoice': invoice, 'entity': 'Positive'}),

        (acct_name, -125, {'invoice': invoice, 'entity': 'Negative'}),

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = related.make_consistent()