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,

        )

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

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

        if post.account.is_under(

                'Accrued:VacationPayable',

                'Expenses:Payroll',

        ):

            return self.DEFAULT_PROJECT

        else:

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

@pytest.fixture(scope='module')

def hook():

    config = testutil.TestConfig(repo_path='repository')

    return meta_project.MetaProject(config)

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

def test_valid_values_on_postings(hook, src_value, set_value):

    txn = testutil.Transaction(postings=[

        ('Assets:Cash', -25),

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

    ])

    errors = list(hook.run(txn))

    assert not errors

    testutil.check_post_meta(txn, None, {TEST_KEY: set_value})

@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 errors

    testutil.check_post_meta(txn, None, {TEST_KEY: src_value})

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

def test_valid_values_on_transactions(hook, src_value, set_value):

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

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    errors = list(hook.run(txn))

    assert not errors

    testutil.check_post_meta(txn, None, {TEST_KEY: set_value})

@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 errors

    testutil.check_post_meta(txn, None, None)

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

    ('Accrued:AccountsReceivable', True),

    ('Assets:Cash', False),

    ('Expenses:General', True),

    ('Income:Donations', True),

    ('Liabilities:CreditCard', False),

    ('UnearnedIncome:Donations', True),

])

def test_which_accounts_required_on(hook, account, required):

    txn = testutil.Transaction(postings=[

        ('Assets:Checking', 25),

        (account, 25),

    ])

    errors = list(hook.run(txn))

    assert required == any(errors)

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

    'Accrued:VacationPayable',

    'Expenses:Payroll:Salary',

    'Expenses:Payroll:Tax',

])

def test_default_values(hook, account):

    txn = testutil.Transaction(postings=[

        ('Assets:Checking', -25),

        (account, 25),

    ])

    errors = list(hook.run(txn))

    assert not errors

    testutil.check_post_meta(txn, None, {TEST_KEY: DEFAULT_VALUE})

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

    (testutil.EXTREME_FUTURE_DATE, False),

    (testutil.FUTURE_DATE, True),

    (testutil.FY_START_DATE, True),

    (testutil.FY_MID_DATE, True),

    (testutil.PAST_DATE, None),

])

def test_default_value_set_in_date_range(hook, date, required):

    txn = testutil.Transaction(date=date, postings=[

        ('Expenses:Payroll:Benefits', 25),

        ('Accrued:VacationPayable', -25),

    ])

    errors = list(hook.run(txn))

    assert not errors

    expect_meta = {TEST_KEY: DEFAULT_VALUE} if required else None

    testutil.check_post_meta(txn, expect_meta, expect_meta)

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

    None,

    '..',

])