def entities(self) -> Iterator[MetaValue]:

        yield from self.accrued_entities

        yield from self.paid_entities.difference(self.accrued_entities)

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

        account_ok = isinstance(self.account, str)

        if len(self.accrued_entities) == 1:

            entity = next(iter(self.accrued_entities))

        else:

            entity = None

        # `'/' 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 is not None 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 = entity if entity is not None 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 report_inconsistencies(self) -> Iterable[Error]:

        for field_name, get_func in self._FIELDS.items():

            if getattr(self, field_name) is self.INCONSISTENT:

                for post in self:

                    errmsg = 'inconsistent {} for invoice {}: {}'.format(

                        field_name.replace('_', '-'),

                        self.invoice or "<none>",

                        get_func(post),

                    )

                    yield Error(post.meta, errmsg, post.meta.txn)

        costs = collections.defaultdict(set)

        for post in self:

            costs[post.units.currency].add(post.cost)

        for code, currency_costs in costs.items():

            if len(currency_costs) > 1:

                for post in self:

                    if post.units.currency == code:

                        errmsg = 'inconsistent cost for invoice {}: {}'.format(

                            self.invoice or "<none>", post.cost,

                        )

                        yield Error(post.meta, errmsg, post.meta.txn)

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

        'Ticket',

        'Invoice',

    ]

    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)

        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)

        self.add_row(

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

            self.multiline_cell(row.entities()),

            amount_cell,

            self.balance_cell(row.end_balance),

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

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

        )

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(

            group.since_last_nonzero()

            for group in groups.values()

            if not group.is_zero()

        )

        rows.sort(key=lambda related: (

            related.account,

            related[0].meta.date,

            min(related.entities()) if related.accrued_entities else '',

        ))

        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: Set[str] = set()

        for post in posts:

            try:

                rt_ids.add(post.meta.get_links('rt-id')[0])

            except (IndexError, TypeError):

                pass

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

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

#!/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"

  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"

  Liabilities:Payable:Accounts  125 USD

  Assets:Checking  -125 USD

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

  rt-id: "rt:470"

  invoice: "rt:470/4700"

  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"

  Assets:Receivable:Accounts  -5000 USD

  Assets:Checking              5000 USD

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

  rt-id: "rt:490"

  invoice: "rt:490/4900"

  Liabilities:Payable:Accounts  -75 USD

  Expenses:Travel  75 USD

2010-04-15 * "Multiparty invoice"

  rt-id: "rt:480"

  invoice: "rt:480/4800"

  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"

  Liabilities:Payable:Accounts  125 USD

  Assets:Checking  -125 USD

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

  rt-id: "rt:480"

  invoice: "rt:480/4800"

  Liabilities:Payable:Accounts  125 USD

  Assets:Checking  -125 USD

2010-04-30 ! "Vendor" "Travel reimbursement"

  rt-id: "rt:310"

  contract: "rt:310/3100"

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

  Liabilities:Payable:Accounts  -200 USD

  Expenses:Travel  200 USD

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

  rt-id: "rt:505"

  invoice: "rt:505/5050"

  approval: "rt:505/5040"

  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"

  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"

  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"

  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"

  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"

  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"

  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"

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

  Expenses:FilingFees  1,000 EUR {1.100 USD}

2010-06-15 * "GrantCo" "2010Q2 grant"

  rt-id: "rt:470"

  invoice: "rt:470/4700"

  Assets:Receivable:Accounts  5500 USD

  Income:Donations           -5500 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',

]

CONSISTENT_METADATA = [

    'contract',

    'purchase-order',

]

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]

    @classmethod

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

    def check_row_match(self, sheet_row):

        cells = testutil.ODSCell.from_row(sheet_row)

        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

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

]

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(