@accounter/server/dist/server/src/modules/ledger/resolvers/ledger-generation/__tests__/monthly-vat-ledger-generation.resolver.test.js

Accounter GraphQL server

import { beforeEach, describe, expect, it, vi } from 'vitest';
import { Currency } from '../../../../../shared/enums.js';
import { AdminContextProvider } from '../../../../admin-context/providers/admin-context.provider.js';
import { getChargeTransactionsMeta } from '../../../../charges/helpers/common.helper.js';
import { getVatRecords } from '../../../../reports/resolvers/get-vat-records.resolver.js';
import { TransactionsProvider } from '../../../../transactions/providers/transactions.provider.js';
import { storeInitialGeneratedRecords } from '../../../helpers/ledgrer-storage.helper.js';
import { generateMiscExpensesLedger } from '../../../helpers/misc-expenses-ledger.helper.js';
import { getVatDataFromVatReportRecords } from '../../../helpers/monthly-vat-ledger-generation.helper.js';
import { getLedgerBalanceInfo, ledgerProtoToRecordsConverter, } from '../../../helpers/utils.helper.js';
import { UnbalancedBusinessesProvider } from '../../../providers/unbalanced-businesses.provider.js';
import { generateLedgerRecordsForMonthlyVat } from '../monthly-vat-ledger-generation.resolver.js';
vi.mock('../../../../charges/helpers/common.helper.js', () => ({
    getChargeTransactionsMeta: vi.fn(),
}));
vi.mock('../../../../reports/resolvers/get-vat-records.resolver.js', () => ({
    getVatRecords: vi.fn(),
}));
vi.mock('../../../helpers/ledgrer-storage.helper.js', () => ({
    storeInitialGeneratedRecords: vi.fn(),
}));
vi.mock('../../../helpers/misc-expenses-ledger.helper.js', () => ({
    generateMiscExpensesLedger: vi.fn(),
}));
vi.mock('../../../helpers/monthly-vat-ledger-generation.helper.js', () => ({
    getVatDataFromVatReportRecords: vi.fn(),
}));
vi.mock('../../../helpers/utils.helper.js', () => {
    class LedgerError extends Error {
    }
    return {
        LedgerError,
        generatePartialLedgerEntry: vi.fn(),
        getFinancialAccountTaxCategoryId: vi.fn(),
        getLedgerBalanceInfo: vi.fn(),
        ledgerProtoToRecordsConverter: vi.fn((records) => records),
        updateLedgerBalanceByEntry: vi.fn(),
        validateTransactionRequiredVariables: vi.fn(),
    };
});
function makeInjector(options = {}) {
    const transactionsByChargeIDLoader = {
        load: vi.fn().mockResolvedValue(options.transactions ?? []),
    };
    const getChargeUnbalancedBusinessesByChargeIds = {
        load: vi.fn().mockResolvedValue(options.unbalancedBusinesses ?? []),
    };
    return {
        get: (token) => {
            if (token === AdminContextProvider) {
                return {
                    getVerifiedAdminContext: vi.fn().mockResolvedValue({
                        defaultLocalCurrency: Currency.Ils,
                        authorities: {
                            vatBusinessId: 'vat-business-id',
                            inputVatTaxCategoryId: 'input-vat-tax-category-id',
                            outputVatTaxCategoryId: 'output-vat-tax-category-id',
                            propertyOutputVatTaxCategoryId: 'property-output-vat-tax-category-id',
                        },
                        general: {
                            taxCategories: {
                                balanceCancellationTaxCategoryId: 'balance-cancellation-tax-category-id',
                            },
                        },
                    }),
                };
            }
            if (token === TransactionsProvider) {
                return {
                    transactionsByChargeIDLoader,
                };
            }
            if (token === UnbalancedBusinessesProvider) {
                return {
                    getChargeUnbalancedBusinessesByChargeIds,
                };
            }
            throw new Error(`Unexpected provider token: ${String(token)}`);
        },
    };
}
describe('generateLedgerRecordsForMonthlyVat validation', () => {
    const chargeBase = {
        id: 'charge-1',
        owner_id: 'owner-1',
        is_property: false,
    };
    beforeEach(() => {
        vi.resetAllMocks();
        vi.mocked(generateMiscExpensesLedger).mockResolvedValue([]);
        vi.mocked(getLedgerBalanceInfo).mockResolvedValue({ isBalanced: true });
        vi.mocked(ledgerProtoToRecordsConverter).mockImplementation(records => records);
        vi.mocked(getVatDataFromVatReportRecords).mockReturnValue([0, 0]);
        vi.mocked(storeInitialGeneratedRecords).mockResolvedValue(undefined);
    });
    it('adds an error when description contains multiple months', async () => {
        vi.mocked(getChargeTransactionsMeta).mockResolvedValue({
            transactionsAmount: -100,
            transactionsMinDebitDate: new Date('2026-05-10T00:00:00.000Z'),
            transactionsMinEventDate: null,
        });
        vi.mocked(getVatRecords).mockResolvedValue({ income: [], expenses: [] });
        const result = await generateLedgerRecordsForMonthlyVat({ ...chargeBase, user_description: 'VAT for 03-04/2026' }, { insertLedgerRecordsIfNotExists: false }, { injector: makeInjector() }, {});
        if (!result || 'message' in result) {
            throw new Error('Expected GeneratedLedgerRecords result');
        }
        expect(result.errors).toContain('Monthly VAT description must include a single report month');
    });
    it('adds an error when transaction date is missing for VAT validation', async () => {
        vi.mocked(getChargeTransactionsMeta).mockResolvedValue({
            transactionsAmount: -100,
            transactionsMinDebitDate: null,
            transactionsMinEventDate: null,
        });
        vi.mocked(getVatRecords).mockResolvedValue({ income: [], expenses: [] });
        const result = await generateLedgerRecordsForMonthlyVat({ ...chargeBase, user_description: 'VAT for 04/2026' }, { insertLedgerRecordsIfNotExists: false }, { injector: makeInjector() }, {});
        if (!result || 'message' in result) {
            throw new Error('Expected GeneratedLedgerRecords result');
        }
        expect(result.errors).toContain('Monthly VAT validation requires at least one transaction date');
    });
    it('adds an error when transactions amount is missing for VAT validation', async () => {
        vi.mocked(getChargeTransactionsMeta).mockResolvedValue({
            transactionsAmount: null,
            transactionsMinDebitDate: new Date('2026-05-10T00:00:00.000Z'),
            transactionsMinEventDate: null,
        });
        vi.mocked(getVatRecords).mockResolvedValue({ income: [], expenses: [] });
        const result = await generateLedgerRecordsForMonthlyVat({ ...chargeBase, user_description: 'VAT for 04/2026' }, { insertLedgerRecordsIfNotExists: false }, { injector: makeInjector() }, {});
        if (!result || 'message' in result) {
            throw new Error('Expected GeneratedLedgerRecords result');
        }
        expect(result.errors).toContain('Monthly VAT validation requires transactions amount');
    });
    it('adds an error when VAT amount does not match transactions sum', async () => {
        vi.mocked(getChargeTransactionsMeta).mockResolvedValue({
            transactionsAmount: -100,
            transactionsMinDebitDate: new Date('2026-05-10T00:00:00.000Z'),
            transactionsMinEventDate: null,
        });
        vi.mocked(getVatRecords).mockResolvedValue({
            income: [{ roundedVATToAdd: 130 }],
            expenses: [{ roundedVATToAdd: 10 }],
        });
        const result = await generateLedgerRecordsForMonthlyVat({ ...chargeBase, user_description: 'VAT for 04/2026' }, { insertLedgerRecordsIfNotExists: false }, { injector: makeInjector() }, {});
        if (!result || 'message' in result) {
            throw new Error('Expected GeneratedLedgerRecords result');
        }
        expect(result.errors).toContain('Monthly VAT amount mismatch for 04/2026');
    });
    it('does not add VAT mismatch validation errors when amounts match', async () => {
        vi.mocked(getChargeTransactionsMeta).mockResolvedValue({
            transactionsAmount: -120,
            transactionsMinDebitDate: new Date('2026-05-10T00:00:00.000Z'),
            transactionsMinEventDate: null,
        });
        vi.mocked(getVatRecords).mockResolvedValue({
            income: [{ roundedVATToAdd: 130 }],
            expenses: [{ roundedVATToAdd: 10 }],
        });
        const result = await generateLedgerRecordsForMonthlyVat({ ...chargeBase, user_description: 'VAT for 04/2026' }, { insertLedgerRecordsIfNotExists: false }, { injector: makeInjector() }, {});
        if (!result || 'message' in result) {
            throw new Error('Expected GeneratedLedgerRecords result');
        }
        expect(result.errors).not.toContain('Monthly VAT amount mismatch for 04/2026');
        expect(result.errors).not.toContain('Monthly VAT validation requires at least one transaction date');
        expect(result.errors).not.toContain('Monthly VAT validation requires transactions amount');
    });
});
//# sourceMappingURL=monthly-vat-ledger-generation.resolver.test.js.map