elif isinstance(rt_id, Sentinel):

            raise ValueError("multiple rt-id links found")

        parsed = rtutil.RT.parse(rt_id)

        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]:

        posts = posts.since_last_nonzero()

        try:

            ticket_id, _ = self._primary_rt_id(posts)

            ticket = self.rt_client.get_ticket(ticket_id)

            # Note we only use this when ticket is None.

            errmsg = f"ticket {ticket_id} not found"

        except (ValueError, rt.RtError) as error:

            ticket = None

            errmsg = error.args[0]

        if ticket is None:

            self.logger.error(

                "can't generate outgoings report for %s because no RT ticket available: %s",

                posts.invoice, errmsg,

            )

            return

        try:

            rt_requestor = self.rt_client.get_user(ticket['Requestors'][0])

        except (IndexError, rt.RtError):

            rt_requestor = None

        if rt_requestor is None:

            requestor = ''

            requestor_name = ''

        else:

            requestor_name = (

                rt_requestor.get('RealName')

                or ticket.get('CF.{payment-to}')

                or ''

            )

            requestor = f'{requestor_name} <{rt_requestor["EmailAddress"]}>'.strip()

        balance_s = posts.end_balance.format(None)

        raw_balance = -posts.balance()

        if raw_balance != posts.end_balance:

            balance_s = f'{raw_balance} ({balance_s})'

        contract_links = list(posts.all_meta_links('contract'))

        if contract_links:

            contract_s = ' , '.join(self.rt_wrapper.iter_urls(

                contract_links, missing_fmt='<BROKEN RT LINK: {}>',

            ))

        else:

            contract_s = "NO CONTRACT GOVERNS THIS TRANSACTION"

        projects = [v for v in posts.meta_values('project')

                    if isinstance(v, str)]

        yield "PAYMENT FOR APPROVAL:"

        yield f"REQUESTOR: {requestor}"

        yield f"TOTAL TO PAY: {balance_s}"

        yield f"AGREEMENT: {contract_s}"

        yield f"PAYMENT TO: {ticket.get('CF.{payment-to}') or requestor_name}"

        yield f"PAYMENT METHOD: {ticket.get('CF.{payment-method}', '')}"

        yield f"PROJECT: {', '.join(projects)}"

        yield "\nBEANCOUNT ENTRIES:\n"

        last_txn: Optional[Transaction] = None

        for post in posts:

            txn = post.meta.txn

            if txn is not last_txn:

                last_txn = txn

                txn = self.rt_wrapper.txn_with_urls(txn, '{}')

                yield bc_printer.format_entry(txn)

class ReportType(enum.Enum):

    AGING = AgingReport

    BALANCE = BalanceReport

    OUTGOING = OutgoingReport

    AGE = AGING

    BAL = BALANCE

    OUT = OUTGOING

    OUTGOINGS = OUTGOING

    @classmethod

    def by_name(cls, name: str) -> 'ReportType':

        try:

            return cls[name.upper()]

        except KeyError:

            raise ValueError(f"unknown report type {name!r}") from None

class ReturnFlag(enum.IntFlag):

    LOAD_ERRORS = 1

    # 2 was used in the past, it can probably be reclaimed.

    REPORT_ERRORS = 4

    NOTHING_TO_REPORT = 8

def filter_search(postings: Iterable[data.Posting],

                  search_terms: Iterable[cliutil.SearchTerm],

) -> Iterable[data.Posting]:

    accounts = tuple(AccrualAccount.account_names())

    postings = (post for post in postings if post.account.is_under(*accounts))

    for query in search_terms:

        postings = query.filter_postings(postings)

    return postings

def parse_arguments(arglist: Optional[Sequence[str]]=None) -> argparse.Namespace:

    parser = argparse.ArgumentParser(prog=PROGNAME)

    cliutil.add_version_argument(parser)

    parser.add_argument(

        '--report-type', '-t',

        metavar='NAME',

        type=ReportType.by_name,

        help="""The type of report to generate, one of `aging`, `balance`, or

`outgoing`. If not specified, the default is `aging` when no search terms are

given, `outgoing` for search terms that return a single outstanding payable,

and `balance` any other time.

""")

    parser.add_argument(

        '--since',

        metavar='YEAR',

        type=int,

        default=-1,

        help="""How far back to search the books for related transactions.

You can either specify a fiscal year, or a negative offset from the current

fiscal year, to start loading entries from. The default is -1 (start from the

previous fiscal year).

""")

    parser.add_argument(

        '--output-file', '-O',

        metavar='PATH',

        type=Path,

        help="""Write the report to this file, or stdout when PATH is `-`.

The default is stdout for the balance and outgoing reports, and a generated

filename for other reports.

""")

    cliutil.add_loglevel_argument(parser)

    parser.add_argument(

        'search_terms',

        metavar='FILTER',

        type=cliutil.SearchTerm.arg_parser('invoice', 'rt-id'),

        nargs=argparse.ZERO_OR_MORE,

        help="""Report on accruals that match this criteria. The format is

NAME=TERM. TERM is a link or word that must exist in a posting's NAME

metadata to match. A single ticket number is a shortcut for

`rt-id=rt:NUMBER`. Any other link, including an RT attachment link in

`TIK/ATT` format, is a shortcut for `invoice=LINK`.

""")

    args = parser.parse_args(arglist)

    if args.report_type is None and not args.search_terms:

        args.report_type = ReportType.AGING

    return args

def main(arglist: Optional[Sequence[str]]=None,

         stdout: TextIO=sys.stdout,

         stderr: TextIO=sys.stderr,

         config: Optional[configmod.Config]=None,

) -> int:

    if cliutil.is_main_script(PROGNAME):

        global logger

        logger = logging.getLogger(PROGNAME)

        sys.excepthook = cliutil.ExceptHook(logger)

    args = parse_arguments(arglist)

    cliutil.setup_logger(logger, args.loglevel, stderr)

    if config is None:

        config = configmod.Config()

        config.load_file()

    returncode = 0

    books_loader = config.books_loader()

    if books_loader is None:

        entries, load_errors, _ = books.Loader.load_none(config.config_file_path())

    elif args.report_type is ReportType.AGING:

        entries, load_errors, _ = books_loader.load_all()

    else:

        entries, load_errors, _ = books_loader.load_all(args.since)

    filters.remove_opening_balance_txn(entries)

    for error in load_errors:

        bc_printer.print_error(error, file=stderr)

        returncode |= ReturnFlag.LOAD_ERRORS

    postings = list(filter_search(

        data.Posting.from_entries(entries), args.search_terms,

    ))

    if not postings:

        logger.warning("no matching entries found to report")

        returncode |= ReturnFlag.NOTHING_TO_REPORT

    groups: PostGroups

    if args.report_type is None or args.report_type is ReportType.OUTGOING:

        groups = dict(AccrualPostings.group_by_first_meta_link(postings, 'rt-id'))

        if (args.report_type is None

            and len(groups) == 1

        ):

            args.report_type = ReportType.OUTGOING

    if args.report_type is not ReportType.OUTGOING:

        groups = {

            key: group

            for _, source in AccrualPostings.group_by_first_meta_link(postings, 'invoice')

            for key, group in source.make_consistent()

        }

    if args.report_type is not ReportType.AGING:

        groups = {

            key: posts for key, posts in groups.items() if not posts.is_paid()

        } or groups

    del postings

    report: Optional[BaseReport] = None

    output_path: Optional[Path] = None

    if args.report_type is ReportType.AGING:

        rt_wrapper = config.rt_wrapper()

        if rt_wrapper is None:

            logger.error("unable to generate aging report: RT client is required")

        else:

            now = datetime.datetime.now()

            if args.output_file is None:

                args.output_file = Path(now.strftime('AgingReport_%Y-%m-%d_%H:%M.ods'))

                logger.info("Writing report to %s", args.output_file)

            out_bin = cliutil.bytes_output(args.output_file, stdout)

            report = AgingReport(rt_wrapper, out_bin)

    elif args.report_type is ReportType.OUTGOING:

        rt_wrapper = config.rt_wrapper()

        if rt_wrapper is None:

            logger.error("unable to generate outgoing report: RT client is required")

        else:

            out_file = cliutil.text_output(args.output_file, stdout)

            report = OutgoingReport(rt_wrapper, out_file)

    else:

        out_file = cliutil.text_output(args.output_file, stdout)

        report = BalanceReport(out_file)

    if report is None:

        returncode |= ReturnFlag.REPORT_ERRORS

    else:

        report.run(groups)

    return 0 if returncode == 0 else 16 + returncode

if __name__ == '__main__':

    exit(main())

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

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

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'babel>=2.6',  # Debian:python3-babel

        'beancount>=2.2',  # Debian:beancount

        # 1.4.1 crashes when trying to save some documents.

        'odfpy>=1.4.0,!=1.4.1',  # Debian:python3-odf

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

        ],

    },

)

2010-01-01 open Assets:Checking

2010-01-01 open Assets:Receivable:Accounts

2010-01-01 open Expenses:FilingFees

2010-01-01 open Expenses:Services:Legal

2010-01-01 open Expenses:Travel

2010-01-01 open Income:Donations

2010-01-01 open Liabilities:Payable:Accounts

2010-01-01 open Equity:Funds:Opening

2010-03-01 * "Opening balances"

  Equity:Funds:Opening  -1000 USD

  Assets:Receivable:Accounts  6000 USD

  Liabilities:Payable:Accounts  -5000 USD

2010-03-05 * "EarlyBird" "Payment for receivable from previous FY"

  rt-id: "rt:40"

  invoice: "rt:40/400"

  project: "Conservancy"

  Assets:Receivable:Accounts  -500 USD

  Assets:Checking  500 USD

2010-03-06 * "EarlyBird" "Payment for payment from previous FY"

  rt-id: "rt:44"

  invoice: "rt:44/440"

  project: "Conservancy"

  Liabilities:Payable:Accounts  125 USD

  Assets:Checking  -125 USD

2010-03-15 * "GrantCo" "2010Q1 grant"

  rt-id: "rt:470"

  invoice: "rt:470/4700"

  project: "Development Grant"

  Assets:Receivable:Accounts  5000 USD

  Income:Donations           -5000 USD

2010-03-25 * "GrantCo" "2010Q1 grant ACH payment"

  rt-id: "rt:470"

  invoice: "rt:470/4700"

  project: "Development Grant"

  Assets:Receivable:Accounts  -5000 USD

  Assets:Checking              5000 USD

2010-03-30 * "EarlyBird" "Travel reimbursement"

  rt-id: "rt:490"

  invoice: "rt:490/4900"

  project: "Conservancy"

  Liabilities:Payable:Accounts  -75 USD

  Expenses:Travel  75 USD

2010-04-15 * "Multiparty invoice"

  rt-id: "rt:480"

  invoice: "rt:480/4800"

  project: "Conservancy"

  Expenses:Travel  250 USD

  Liabilities:Payable:Accounts  -125 USD

  entity: "MultiPartyA"

  Liabilities:Payable:Accounts  -125 USD

  entity: "MultiPartyB"

2010-04-18 * "MultiPartyA" "Payment for 480"

  rt-id: "rt:480"

  invoice: "rt:480/4800"

  project: "Conservancy"

  Liabilities:Payable:Accounts  125 USD

  Assets:Checking  -125 USD

2010-04-20 * "MultiPartyB" "Payment for 480"

  rt-id: "rt:480"

  invoice: "rt:480/4800"

  project: "Conservancy"

  Liabilities:Payable:Accounts  125 USD

  Assets:Checking  -125 USD

2010-04-25 ! "Vendor" "First trip travel reimbursement"

  rt-id: "rt:310"

  contract: "rt:310/3100"

  invoice: "FIXME"  ; still waiting on them to send it

  project: "Conservancy"

  Liabilities:Payable:Accounts  -200 USD

  Expenses:Travel  200 USD

2010-04-30 * "Vendor" "Second trip travel reimbursement"

  rt-id: "rt:310"

  contract: "rt:310/3100"

  invoice: "rt:310/3120"

  project: "Conservancy"

  Liabilities:Payable:Accounts  -220 USD

  Expenses:Travel  220 USD

2010-05-05 * "DonorA" "Donation pledge"

  rt-id: "rt:505"

  invoice: "rt:505/5050"

  approval: "rt:505/5040"

  project: "Conservancy"

  Income:Donations  -2,500 EUR {1.100 USD}

  Assets:Receivable:Accounts  2,500 EUR {1.100 USD}

2010-05-10 * "Lawyer" "April legal services"

  rt-id: "rt:510"

  invoice: "rt:510/5100"

  contract: "rt:510/4000"

  project: "Conservancy"

  Expenses:Services:Legal  200.00 USD

  Liabilities:Payable:Accounts  -200.00 USD

2010-05-15 * "MatchingProgram" "May matched donations"

  invoice: "rt://ticket/515/attachments/5150"

  approval: "rt://ticket/515/attachments/5140"

  project: "Conservancy"

  Income:Donations  -1500.00 USD

  Assets:Receivable:Accounts  1500.00 USD

2010-05-20 * "DonorA" "Donation made"

  rt-id: "rt:505"

  invoice: "rt:505/5050"

  project: "Conservancy"

  Assets:Receivable:Accounts  -2,750.00 USD

  Assets:Checking  2,750.00 USD

  receipt: "DonorAWire.pdf"

2010-05-25 * "Lawyer" "May payment"

  rt-id: "rt:510"

  invoice: "rt:510/5100"

  project: "Conservancy"

  Liabilities:Payable:Accounts  200.00 USD

  contract: "rt:510/4000"

  Assets:Checking  -200.00 USD

  receipt: "rt:510/5105"

2010-06-10 * "Lawyer" "May legal services"

  rt-id: "rt:510"

  invoice: "rt:510/6100"

  contract: "rt:510/4000"

  project: "Conservancy"

  Expenses:Services:Legal  220.00 USD

  Liabilities:Payable:Accounts  -220.00 USD

2010-06-12 * "Lawyer" "Additional legal fees for May"

  rt-id: "rt:510"

  invoice: "rt:510/6100"

  contract: "rt:510/4000"

  project: "Conservancy"

  Expenses:FilingFees  60.00 USD

  Liabilities:Payable:Accounts  -60.00 USD

2010-06-18 * "EuroGov" "European legal fees"

  ; Multiple rt-ids are used to test proper handling for both

  ; searching and generating the outgoing report.

  rt-id: "rt:520 rt:525"

  invoice: "rt:520/5200"

  contract: "rt:520/5220"

  project: "Conservancy"

  Liabilities:Payable:Accounts  -1,000 EUR {1.100 USD}

  Expenses:FilingFees  1,000 EUR {1.100 USD}

2010-09-15 * "GrantCo" "2010Q3 grant"

  rt-id: "rt:470"

  invoice: "rt:470/4700"

  project: "Development Grant"

  Assets:Receivable:Accounts  6000 USD

  Income:Donations           -6000 USD

"""test_reports_accrual - Unit tests for accrual report"""

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

import datetime

import io

import itertools

import logging

import operator

import re

import babel.numbers

import odf.opendocument

import odf.table

import odf.text

import pytest

from . import testutil

from decimal import Decimal

from typing import NamedTuple, Optional, Sequence

from beancount.core import data as bc_data

from beancount import loader as bc_loader

from conservancy_beancount import cliutil

from conservancy_beancount import data

from conservancy_beancount import rtutil

from conservancy_beancount.reports import accrual

from conservancy_beancount.reports import core

_accruals_load = bc_loader.load_file(testutil.test_path('books/accruals.beancount'))

ACCRUAL_TXNS = [

    entry for entry in _accruals_load[0]

    if hasattr(entry, 'narration')

    and entry.narration != 'Opening balances'

]

ACCRUALS_COUNT = sum(

    1

    for txn in ACCRUAL_TXNS

    for post in txn.postings

    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)

            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-25', 'Vendor', 200, 'FIXME'),

    AgingRow.make_simple('2010-04-30', 'Vendor', 220, 'rt:310/3120'),

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

        ],

        '310': [

            ('3100', 'VendorContract.pdf', 'application/pdf', '1.7m'),

            ('3120', 'VendorInvoiceB.pdf', 'application/pdf', '1.8m'),

        ],

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

        # Expenses posting.

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

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

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

        r'^\s*2010-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, caplog):

    rt_client = RTClient(want_cfs=False)

    output = run_outgoing('rt:510', accrual_postings, rt_client)

    assert not caplog.records

    check_output(output, [

        r'^PAYMENT FOR APPROVAL:$',

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

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

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

    ])

def test_outgoing_report_fx_amounts(accrual_postings, caplog):

    output = run_outgoing('rt:520 rt:525', accrual_postings)

    assert not caplog.records

    check_output(output, [

        r'^PAYMENT FOR APPROVAL:$',

        r'^REQUESTOR: Mx\. 520 <mx520@example\.org>$',

        r'^TOTAL TO PAY: 1,000\.00 EUR \(\$1,100.00\)$',

    ])

def test_outgoing_report_multi_invoice(accrual_postings, caplog):

    output = run_outgoing('rt:310', accrual_postings)

    assert not caplog.records

    check_output(output, [

        r'^PAYMENT FOR APPROVAL:$',

        r'^REQUESTOR: Mx\. 310 <mx310@example\.org>$',

        r'^TOTAL TO PAY: \$420.00$',

    ])

def test_outgoing_report_without_rt_id(accrual_postings, caplog):

    invoice = 'rt://ticket/515/attachments/5150'

    related = accruals_by_meta(

        accrual_postings, invoice, wrap_type=accrual.AccrualPostings,

    )

    output = run_outgoing(None, related)

    assert caplog.records

    log = caplog.records[0]

    assert log.message.startswith(

        f"can't generate outgoings report for {invoice} because no RT ticket available:",

    )

    assert not output.getvalue()

def run_aging_report(postings, today=None):

    if today is None:

        today = datetime.date.today()

    postings = (

        post for post in postings

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

    )

    groups = {

        key: group

        for _, related in accrual.AccrualPostings.group_by_meta(postings, 'invoice')

        for key, group in related.make_consistent()

    }

    output = io.BytesIO()

    rt_wrapper = rtutil.RT(RTClient())

    report = accrual.AgingReport(rt_wrapper, output, today)

    report.run(groups)

    return output

def test_aging_report(accrual_postings):

    output = run_aging_report(accrual_postings)

    check_aging_ods(output)

@pytest.mark.parametrize('date,recv_end,pay_end', [

    # Both these dates are chosen for their off-by-one potential:

    # the first is exactly 30 days after the 2010-06-10 payable;

    # the second is exactly 60 days after the 2010-05-15 receivable.

    (datetime.date(2010, 7, 10), 1, 5),

    (datetime.date(2010, 7, 14), 2, 5),

])

def test_aging_report_date_cutoffs(accrual_postings, date, recv_end, pay_end):

    expect_recv = AGING_AR[:recv_end]

    expect_pay = AGING_AP[:pay_end]

    if 10 <= date.day < 12:

        # Take the 60 USD posting out of the invoice 510/6100 payable.

        expect_pay[-1] = expect_pay[-1]._replace(

            at_cost=testutil.Amount(expect_pay[-1].at_cost.number - 60),

        )

    output = run_aging_report(accrual_postings, date)

    check_aging_ods(output, date, expect_recv, expect_pay)