`foo in generic_range` is equivalent to `start <= foo < stop`.

    Since we have multiple user-configurable ranges, having the check

    encapsulated in an object helps implement the check consistently, and

    makes it easier for subclasses to override.

    """

    def __init__(self, start: CT, stop: CT) -> None:

        self.start = start

        self.stop = stop

    def __repr__(self) -> str:

        return "{clsname}({self.start!r}, {self.stop!r})".format(

            clsname=type(self).__name__,

            self=self,

        )

    def __contains__(self, item: CT) -> bool:

        return self.start <= item < self.stop

class MetadataEnum:

    """Map acceptable metadata values to their normalized forms.

    When a piece of metadata uses a set of allowed values, use this class to

    define them. You can also specify aliases that hooks will normalize to

    the primary values.

    """

    def __init__(self,

                 key: MetaKey,

                 standard_values: Iterable[MetaValueEnum],

                 aliases_map: Optional[Mapping[MetaValueEnum, MetaValueEnum]]=None,

    ) -> None:

        """Specify allowed values and aliases for this metadata.

        Arguments:

        * key: The name of the metadata key that uses this enum.

        * standard_values: A sequence of strings that enumerate the standard

          values for this metadata.

        * aliases_map: A mapping of strings to strings. The keys are

          additional allowed metadata values. The values are standard values

          that each key will evaluate to. The code asserts that all values are

          in standard_values.

        """

        self.key = key

        self._stdvalues = frozenset(standard_values)

        self._aliases: Dict[MetaValueEnum, MetaValueEnum] = dict(aliases_map or ())

        assert self._stdvalues.issuperset(self._aliases.values())

        self._aliases.update((v, v) for v in standard_values)

    def __repr__(self) -> str:

        return "{}<{}>".format(type(self).__name__, self.key)

    def __contains__(self, key: MetaValueEnum) -> bool:

        """Returns true if `key` is a standard value or alias."""

        return key in self._aliases

    def __getitem__(self, key: MetaValueEnum) -> MetaValueEnum:

        """Return the standard value for `key`.

        Raises KeyError if `key` is not a known value or alias.

        """

        return self._aliases[key]

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

        """Iterate over standard values."""

        return iter(self._stdvalues)

    def get(self,

            key: MetaValueEnum,

            default_key: Optional[MetaValueEnum]=None,

    ) -> Optional[MetaValueEnum]:

        """Return self[key], or a default fallback if that doesn't exist.

        default_key is another key to look up, *not* a default value to return.

        This helps ensure you always get a standard value.

        """

        try:

            return self[key]

        except KeyError:

            if default_key is None:

                return None

            else:

                return self[default_key]

### HOOK SUBCLASSES

class _PostingHook(TransactionHook, metaclass=abc.ABCMeta):

    TXN_DATE_RANGE: _GenericRange = _GenericRange(DEFAULT_START_DATE, DEFAULT_STOP_DATE)

    def __init_subclass__(cls) -> None:

        cls.HOOK_GROUPS = cls.HOOK_GROUPS.union(['posting'])

    def _run_on_txn(self, txn: Transaction) -> bool:

    def _run_on_post(self, txn: Transaction, post: data.Posting) -> bool:

        return True

    def run(self, txn: Transaction) -> errormod.Iter:

        if self._run_on_txn(txn):

            for post in data.iter_postings(txn):

                if self._run_on_post(txn, post):

                    yield from self.post_run(txn, post)

    @abc.abstractmethod

    def post_run(self, txn: Transaction, post: data.Posting) -> errormod.Iter: ...

class _NormalizePostingMetadataHook(_PostingHook):

    """Base class to normalize posting metadata from an enum."""

    # This class provides basic functionality to filter postings, normalize

    # metadata values, and set default values.

    METADATA_KEY: MetaKey

    VALUES_ENUM: MetadataEnum

    def __init_subclass__(cls) -> None:

        super().__init_subclass__()

        cls.METADATA_KEY = cls.VALUES_ENUM.key

        cls.HOOK_GROUPS = cls.HOOK_GROUPS.union(['metadata', cls.METADATA_KEY])

    # If the posting does not specify METADATA_KEY, the hook calls

    # _default_value to get a default. This method should either return

    # a value string from METADATA_ENUM, or else raise InvalidMetadataError.

    # This base implementation does the latter.

    def _default_value(self, txn: Transaction, post: data.Posting) -> MetaValueEnum:

        raise errormod.InvalidMetadataError(txn, self.METADATA_KEY, None, post)

    def post_run(self, txn: Transaction, post: data.Posting) -> errormod.Iter:

        source_value = post.meta.get(self.METADATA_KEY)

        set_value = source_value

        error: Optional[errormod.Error] = None

        if source_value is None:

            try:

                set_value = self._default_value(txn, post)

            except errormod.Error as error_:

                error = error_

        else:

            try:

                set_value = self.VALUES_ENUM[source_value]

            except KeyError:

                error = errormod.InvalidMetadataError(

                    txn, self.METADATA_KEY, source_value, post,

                )

        if error is None:

            post.meta[self.METADATA_KEY] = set_value

        else:

            yield error

class _RequireLinksPostingMetadataHook(_PostingHook):

    """Base class to require that posting metadata include links"""

    # This base class confirms that a posting's metadata has one or more links

    # under one of the metadata keys listed in CHECKED_METADATA.

    # Most subclasses only need to define CHECKED_METADATA and _run_on_post.

    CHECKED_METADATA: Sequence[MetaKey]

    def __init_subclass__(cls) -> None:

        super().__init_subclass__()

        cls.HOOK_GROUPS = cls.HOOK_GROUPS.union(cls.CHECKED_METADATA).union('metadata')

    def _check_metadata(self,

                        txn: Transaction,

                        post: data.Posting,

                        keys: Sequence[MetaKey],

    ) -> Iterable[errormod.InvalidMetadataError]:

        have_docs = False

        for key in keys:

            try:

                links = post.meta.get_links(key)

            except TypeError as error:

                yield errormod.InvalidMetadataError(txn, key, post.meta[key], post)

            else:

                have_docs = have_docs or any(links)

        if not have_docs:

            yield errormod.InvalidMetadataError(txn, '/'.join(keys), None, post)

    def post_run(self, txn: Transaction, post: data.Posting) -> errormod.Iter:

        return self._check_metadata(txn, post, self.CHECKED_METADATA)

"""meta_entity - Validate entity metadata"""

# 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/>.

# Type stubs aren't available for regex.

# Fortunately, we're using it in a way that's API-compatible with the re

# module. We mitigate the lack of type stubs by providing type declarations

# for returned objects. This way, the only thing that isn't type checked are

# the calls to regex functions.

import regex  # type:ignore[import]

from . import core

from .. import data

from .. import errors as errormod

from ..beancount_types import (

    Transaction,

)

from typing import (

    Pattern,

)

class MetaEntity(core.TransactionHook):

    METADATA_KEY = 'entity'

    HOOK_GROUPS = frozenset(['posting', 'metadata', METADATA_KEY])

    # alnum is the set of characters we always accept in entity metadata:

    # letters and digits, minus the Latin 1 supplement (i.e., Roman letters

    # with diacritics: áÁàÀâÂåÅäÄãà çÇ ðÐ ñÑ øØ ß etc.)

    # See the tests for specific cases.

    alnum = r'\p{Letter}\p{Digit}--\p{Block=Latin_1_Supplement}'

    # A regexp that would be reasonably stricter would be:

    #   f'^[{alnum}][.{alnum}]*(?:-[.{alnum}])*$'

    # However, current producers fail that regexp in a few different ways.

    # See the tests for specific cases.

    ENTITY_RE: Pattern[str] = regex.compile(f'^[{alnum}][-.{alnum}]*$', regex.VERSION1)

    del alnum

    def run(self, txn: Transaction) -> errormod.Iter:

        txn_entity = txn.meta.get(self.METADATA_KEY, txn.payee)

        if txn_entity is None:

            txn_entity_ok = None

        elif isinstance(txn_entity, str):

            txn_entity_ok = bool(self.ENTITY_RE.match(txn_entity))

        else:

            txn_entity_ok = False

        if txn_entity_ok is False:

            yield errormod.InvalidMetadataError(txn, self.METADATA_KEY, txn_entity)

        for post in data.iter_postings(txn):

            if not post.account.is_under(

                    'Assets:Receivable',

                    'Expenses',

                    'Income',

                    'Liabilities:Payable',

            ):

                continue

            entity = post.meta.get(self.METADATA_KEY)

            if entity is None:

                yield errormod.InvalidMetadataError(txn, self.METADATA_KEY, entity, post)

            elif entity is txn_entity:

                pass

            elif not self.ENTITY_RE.match(entity):

                yield errormod.InvalidMetadataError(txn, self.METADATA_KEY, entity, post)

"""meta_project - Validate project metadata"""

# 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/>.

from pathlib import Path

import yaml

import yaml.error

from . import core

from .. import config as configmod

from .. import data

from .. import errors as errormod

from ..beancount_types import (

    MetaValueEnum,

    Transaction,

)

from typing import (

    Any,

    Dict,

    NoReturn,

    Optional,

    Set,

)

class MetaProject(core._NormalizePostingMetadataHook):

    DEFAULT_PROJECT = 'Conservancy'

    PROJECT_DATA_PATH = Path('Projects', 'project-data.yml')

    VALUES_ENUM = core.MetadataEnum('project', {DEFAULT_PROJECT})

    def __init__(self, config: configmod.Config, source_path: Path=PROJECT_DATA_PATH) -> None:

        repo_path = config.repository_path()

        if repo_path is None:

            self._config_error("no repository configured")

        project_data_path = repo_path / source_path

        source = {'filename': str(project_data_path)}

        try:

            with project_data_path.open() as yaml_file:

                project_data: Dict[str, Dict[str, Any]] = yaml.safe_load(yaml_file)

            names: Set[MetaValueEnum] = {self.DEFAULT_PROJECT}

            aliases: Dict[MetaValueEnum, MetaValueEnum] = {}

            for key, params in project_data.items():

                name = params.get('accountName', key)

                names.add(name)

                human_name = params.get('humanName', name)

                if name != human_name:

                    aliases[human_name] = name

                if name != key:

                    aliases[key] = name

        except AttributeError:

            self._config_error("loaded YAML data not in project-data format", project_data_path)

        except OSError as error:

            self._config_error(error.strerror, project_data_path)

        except yaml.error.YAMLError as error:

            self._config_error(error.args[0] or "YAML load error", project_data_path)

        else:

            self.VALUES_ENUM = core.MetadataEnum(self.METADATA_KEY, names, aliases)

    def _config_error(self, msg: str, filename: Optional[Path]=None) -> NoReturn:

        source = {}

        if filename is not None:

            source['filename'] = str(filename)

        raise errormod.ConfigurationError(

            "cannot load project data: " + msg,

            source=source,

        )

        if post.account.is_under('Liabilities'):

            return not post.account.is_credit_card()

        else:

            return post.account.is_under(

                'Assets:Receivable',

                'Expenses',

                'Income',

            ) is not None

    def _default_value(self, txn: Transaction, post: data.Posting) -> MetaValueEnum:

        if post.account.is_under(

                'Expenses:Payroll',

                'Liabilities:Payable:Vacation',

        ):

            return self.DEFAULT_PROJECT

        else:

            raise errormod.InvalidMetadataError(txn, self.METADATA_KEY, None, post)

def hook():

    config = testutil.TestConfig()

    return meta_entity.MetaEntity(config)

@pytest.mark.parametrize('src_value', VALID_VALUES)

def test_valid_values_on_postings(hook, src_value):

    txn = testutil.Transaction(postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25, {TEST_KEY: src_value}),

    ])

    assert not any(hook.run(txn))

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_postings(hook, src_value):

    txn = testutil.Transaction(postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25, {TEST_KEY: src_value}),

    ])

    errors = list(hook.run(txn))

    assert len(errors) == 1

    assert errors[0].message == "Expenses:General has invalid entity: {}".format(src_value)

@pytest.mark.parametrize('src_value', VALID_VALUES)

def test_valid_values_on_transactions(hook, src_value):

    txn = testutil.Transaction(**{TEST_KEY: src_value}, postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    assert not any(hook.run(txn))

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_transactions(hook, src_value):

    txn = testutil.Transaction(**{TEST_KEY: src_value}, postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    errors = list(hook.run(txn))

    assert 1 <= len(errors) <= 2

    assert all(error.message == "transaction has invalid entity: {}".format(src_value)

               for error in hook.run(txn))

@pytest.mark.parametrize('src_value', VALID_VALUES)

def test_valid_values_on_payee(hook, src_value):

    txn = testutil.Transaction(payee=src_value, postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    assert not any(hook.run(txn))

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_payee(hook, src_value):

    txn = testutil.Transaction(payee=src_value, postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    errors = list(hook.run(txn))

    assert 1 <= len(errors) <= 2

    assert all(error.message == "transaction has invalid entity: {}".format(src_value)

               for error in hook.run(txn))

@pytest.mark.parametrize('payee,src_value', testutil.combine_values(

    INVALID_VALUES,

    VALID_VALUES,

))

def test_invalid_payee_but_valid_metadata(hook, payee, src_value):

    txn = testutil.Transaction(**{'payee': payee, TEST_KEY: src_value}, postings=[

        ('Assets:Cash', -25),

        ('Expenses:Other', 25),

    ])

    assert not any(hook.run(txn))

@pytest.mark.parametrize('account,required', [

    ('Assets:Bank:Checking', False),

    ('Assets:Cash', False),

    ('Assets:Receivable:Accounts', True),

    ('Assets:Receivable:Loans', True),

    ('Equity:OpeningBalances', False),

    ('Expenses:General', True),

    ('Income:Donations', True),

    ('Liabilities:CreditCard', False),

    ('Liabilities:Payable:Accounts', True),

    ('Liabilities:Payable:Vacation', True),

    ('Liabilities:UnearnedIncome:Donations', False),

])

def test_which_accounts_required_on(hook, account, required):

    txn = testutil.Transaction(postings=[

        ('Assets:Checking', -25),

        (account, 25),

    ])

    errors = list(hook.run(txn))

    if not required:

        assert not errors

    else:

        assert errors

        assert any(error.message == "{} missing entity".format(account)

                   for error in errors)

"""Test validation of invoice metadata"""

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

from . import testutil

from conservancy_beancount.plugin import meta_invoice

REQUIRED_ACCOUNTS = {

    'Assets:Receivable:Accounts',

    'Assets:Receivable:Loans',

    'Liabilities:Payable:Accounts',

    'Liabilities:Payable:Vacation',

}

NON_REQUIRED_ACCOUNTS = {

    'Assets:Cash',

    'Expenses:Other',

    'Income:Other',

    'Liabilities:CreditCard',

}

TEST_KEY = 'invoice'

MISSING_MSG = f'{{}} missing {TEST_KEY}'.format

WRONG_TYPE_MSG = f'{{}} has wrong type of {TEST_KEY}: expected str but is a {{}}'.format

@pytest.fixture(scope='module')

def hook():

    config = testutil.TestConfig()

    return meta_invoice.MetaInvoice(config)

@pytest.mark.parametrize('acct1,acct2,value', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

    testutil.LINK_METADATA_STRINGS,

))

def test_valid_values_on_postings(hook, acct1, acct2, value):

    txn = testutil.Transaction(postings=[

        (acct2, -25),

        (acct1, 25, {TEST_KEY: value}),

    ])

    assert not list(hook.run(txn))

@pytest.mark.parametrize('acct1,acct2,value', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

    testutil.NON_LINK_METADATA_STRINGS,

))

def test_invalid_values_on_postings(hook, acct1, acct2, value):

    txn = testutil.Transaction(postings=[

        (acct2, -25),

        (acct1, 25, {TEST_KEY: value}),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {"{} missing {}".format(acct1, TEST_KEY)}

@pytest.mark.parametrize('acct1,acct2,value', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

    testutil.NON_STRING_METADATA_VALUES,

))

def test_bad_type_values_on_postings(hook, acct1, acct2, value):

    txn = testutil.Transaction(postings=[

        (acct2, -25),

        (acct1, 25, {TEST_KEY: value}),

    ])

    expected = {

        MISSING_MSG(acct1),

        WRONG_TYPE_MSG(acct1, type(value).__name__),

    }

    actual = {error.message for error in hook.run(txn)}

    assert actual == expected

@pytest.mark.parametrize('acct1,acct2,value', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

    testutil.LINK_METADATA_STRINGS,

))

def test_valid_values_on_transaction(hook, acct1, acct2, value):

    txn = testutil.Transaction(**{TEST_KEY: value}, postings=[

        (acct2, -25),

        (acct1, 25),

    ])

    assert not list(hook.run(txn))

@pytest.mark.parametrize('acct1,acct2,value', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

    testutil.NON_LINK_METADATA_STRINGS,

))

def test_invalid_values_on_transaction(hook, acct1, acct2, value):

    txn = testutil.Transaction(**{TEST_KEY: value}, postings=[

        (acct2, -25),

        (acct1, 25),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {"{} missing {}".format(acct1, TEST_KEY)}

@pytest.mark.parametrize('acct1,acct2,value', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

    testutil.NON_STRING_METADATA_VALUES,

))

def test_bad_type_values_on_transaction(hook, acct1, acct2, value):

    txn = testutil.Transaction(**{TEST_KEY: value}, postings=[

        (acct2, -25),

        (acct1, 25),

    ])

    expected = {

        MISSING_MSG(acct1),

        WRONG_TYPE_MSG(acct1, type(value).__name__),

    }

    actual = {error.message for error in hook.run(txn)}

    assert actual == expected

@pytest.mark.parametrize('acct1,acct2', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

))

def test_missing_invoice(hook, acct1, acct2):

    txn = testutil.Transaction(postings=[

        (acct2, -25),

        (acct1, 25),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {"{} missing {}".format(acct1, TEST_KEY)}

        (other_acct, amount),

    ])

    actual = {error.message for error in hook.run(txn)}

    if expected is None:

        assert not actual

    elif isinstance(expected, str):

        assert expected in actual

    else:

        assert actual == expected

@pytest.mark.parametrize('support_key,support_value', testutil.combine_values(

    SUPPORTING_METADATA,

    testutil.LINK_METADATA_STRINGS,

))

def test_valid_docs_in_post(hook, support_key, support_value):

    meta = seed_meta()

    meta[support_key] = support_value

    check(hook, None, post_meta=meta)

@pytest.mark.parametrize('support_key,support_value', testutil.combine_values(

    SUPPORTING_METADATA,

    testutil.LINK_METADATA_STRINGS,

))

def test_valid_docs_in_txn(hook, support_key, support_value):

    meta = seed_meta()

    meta[support_key] = support_value

    check(hook, None, txn_meta=meta)

@pytest.mark.parametrize('meta_type', ['post_meta', 'txn_meta'])

def test_no_valid_docs(hook, meta_type):

    meta = seed_meta()

    meta.update((key, value) for key, value in testutil.combine_values(

        NON_SUPPORTING_METADATA,

        testutil.LINK_METADATA_STRINGS,

    ))

    check(hook, {MISSING_MSG}, **{meta_type: meta})

@pytest.mark.parametrize('meta_type', ['post_meta', 'txn_meta'])

def test_docs_all_bad_type(hook, meta_type):

    meta = seed_meta(testutil.NON_STRING_METADATA_VALUES)

    expected = {

        wrong_type_message(key, value)

        for key, value in meta.items()

    }

    expected.add(MISSING_MSG)

    check(hook, expected, **{meta_type: meta})

@pytest.mark.parametrize('support_key,support_value', testutil.combine_values(

    SUPPORTING_METADATA,

    testutil.LINK_METADATA_STRINGS,

))

def test_type_errors_reported_with_valid_post_docs(hook, support_key, support_value):

    meta = seed_meta(testutil.NON_STRING_METADATA_VALUES)

    meta[support_key] = support_value

    expected = {

        wrong_type_message(key, value)

        for key, value in meta.items()

        if key != support_key

    }

    check(hook, expected, post_meta=meta)

@pytest.mark.parametrize('support_key,support_value', testutil.combine_values(

    SUPPORTING_METADATA,

    testutil.LINK_METADATA_STRINGS,

))

def test_type_errors_reported_with_valid_txn_docs(hook, support_key, support_value):

    meta = seed_meta(testutil.NON_STRING_METADATA_VALUES)

    meta[support_key] = support_value

    expected = {

        wrong_type_message(key, value)

        for key, value in meta.items()

        if key != support_key

    }

    check(hook, expected, txn_meta=meta)

def test_paid_accts_not_checked(hook):

    txn = testutil.Transaction(postings=[

        (TEST_ACCT, 250),

        (OTHER_ACCT, -250),

    ])

    assert not list(hook.run(txn))

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

    'Assets:Bank:Checking',

    'Assets:Cash',

    'Assets:Receivable:Accounts',

    'Equity:OpeningBalance',

    'Expenses:BankingFees',

    'Income:Donations',

    'Liabilities:CreditCard',

    'Liabilities:Payable:Vacation',

    'Liabilities:UnearnedIncome:Donations',

])

def test_does_not_apply_to_other_accounts(hook, account):

    meta = seed_meta()

    check(hook, None, account, post_meta=meta)

        (paypal_account_for_id(src_value), 25, {TEST_KEY: src_value}),

    ])

    assert not list(hook.run(txn))

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_postings(hook, src_value):

    acct = paypal_account_for_id(src_value)

    txn = testutil.Transaction(postings=[

        ('Income:Donations', -25),

        (acct, 25, {TEST_KEY: src_value}),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {INVALID_MSG(acct, src_value)}

@pytest.mark.parametrize('src_value,acct', testutil.combine_values(

    testutil.NON_STRING_METADATA_VALUES,

    ACCOUNTS,

))

def test_bad_type_values_on_postings(hook, src_value, acct):

    txn = testutil.Transaction(postings=[

        ('Income:Donations', -25),

        (acct, 25, {TEST_KEY: src_value}),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {BAD_TYPE_MSG(acct, type(src_value).__name__)}

@pytest.mark.parametrize('src_value', VALID_VALUES)

def test_valid_values_on_transactions(hook, src_value):

    txn = testutil.Transaction(**{TEST_KEY: src_value}, postings=[

        ('Income:Donations', -25),

        (paypal_account_for_id(src_value), 25),

    ])

    assert not list(hook.run(txn))

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_transactions(hook, src_value):

    acct = paypal_account_for_id(src_value)

    txn = testutil.Transaction(**{TEST_KEY: src_value}, postings=[

        ('Income:Donations', -25),

        (acct, 25),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {INVALID_MSG(acct, src_value)}

@pytest.mark.parametrize('src_value,acct', testutil.combine_values(

    testutil.NON_STRING_METADATA_VALUES,

    ACCOUNTS,

))

def test_bad_type_values_on_transactions(hook, src_value, acct):

    txn = testutil.Transaction(**{TEST_KEY: src_value}, postings=[

        ('Income:Donations', -25),

        (acct, 25),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {BAD_TYPE_MSG(acct, type(src_value).__name__)}

@pytest.mark.parametrize('src_value', VALID_INVOICE_IDS)

def test_invoice_ids_not_accepted_for_non_accruals(hook, src_value):

    acct = 'Assets:PayPal'

    txn = testutil.Transaction(**{TEST_KEY: src_value}, postings=[

        ('Income:Donations', -25),

        (acct, 25),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {INVALID_MSG(acct, src_value)}

@pytest.mark.parametrize('src_value', VALID_TXN_IDS)

def test_transaction_ids_not_accepted_for_accruals(hook, src_value):

    acct = 'Assets:Receivable:Accounts'

    txn = testutil.Transaction(**{TEST_KEY: src_value}, postings=[

        ('Income:Donations', -25),

        (acct, 25),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {INVALID_MSG(acct, src_value)}

def test_required_for_assets_paypal(hook):

    acct = 'Assets:PayPal'

    txn = testutil.Transaction(postings=[

        ('Income:Donations', -35),

        (acct, 35),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {f"{acct} missing {TEST_KEY}"}

@pytest.mark.parametrize('txn_id,inv_id', testutil.combine_values(

    VALID_TXN_IDS,

    VALID_INVOICE_IDS,

))

def test_invoice_payment_transaction_ok(hook, txn_id, inv_id):

    txn = testutil.Transaction(**{TEST_KEY: txn_id}, postings=[

        ('Assets:Receivable:Accounts', -100, {TEST_KEY: inv_id}),

        ('Assets:PayPal', 97),

        ('Expenses:BankingFees', 3),

    ])

    assert not list(hook.run(txn))

"""Test handling of project metadata"""

# 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