@novha/calc-engines 2.0.2 → 3.0.0

package/test/uk-corporate-tax.test.ts

@@ -0,0 +1,119 @@
+import { UKCorporateTaxServiceImpl } from '../src/corporate/uk/UKCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/uk/domain/types';
+
+// UK 2024-25 corporate tax rules
+const ukCorporateRules: Rules = {
+    regimes: {
+        smallProfits: {
+            type: 'flat',
+            rate: 0.19,
+        },
+        main: {
+            type: 'flat',
+            rate: 0.25,
+        },
+        marginalRelief: {
+            type: 'marginal_relief',
+            mainRate: 0.25,
+            smallProfitsRate: 0.19,
+            upperLimit: 250000,
+            lowerLimit: 50000,
+            standardFraction: 3 / 200,
+        },
+    },
+};
+
+describe('UKCorporateTaxServiceImpl', () => {
+    it('applies small profits rate (19%) for profits up to £50,000', () => {
+        const input: Input = { taxableIncome: 50000 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(9500);
+        expect(result.effectiveTaxRate).toBe(19);
+    });
+
+    it('applies main rate (25%) for profits above £250,000', () => {
+        const input: Input = { taxableIncome: 300000 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(75000);
+        expect(result.effectiveTaxRate).toBe(25);
+    });
+
+    it('applies marginal relief for profits between £50,000 and £250,000', () => {
+        // At £150,000:
+        // Gross tax = 150000 * 25% = 37500
+        // Relief = (3/200) * (250000 - 150000) = 0.015 * 100000 = 1500
+        // Net tax = 37500 - 1500 = 36000
+        const input: Input = { taxableIncome: 150000 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(36000);
+    });
+
+    it('marginal relief at lower limit boundary produces 19% effective rate', () => {
+        // At £50,001 (just above lower limit):
+        // Gross tax = 50001 * 25% = 12500.25
+        // Relief = (3/200) * (250000 - 50001) = 0.015 * 199999 = 2999.985
+        // Net tax ≈ 9500.265
+        // Effective rate ≈ 19.00%
+        const input: Input = { taxableIncome: 50001 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(19, 0);
+    });
+
+    it('marginal relief at upper limit boundary produces 25% effective rate', () => {
+        // At £249,999:
+        // Gross tax = 249999 * 25% = 62499.75
+        // Relief = (3/200) * (250000 - 249999) = 0.015 * 1 = 0.015
+        // Net tax ≈ 62499.735
+        // Effective rate ≈ 25%
+        const input: Input = { taxableIncome: 249999 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(25, 0);
+    });
+
+    it('returns zero tax for zero taxable income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('returns breakdowns for small profits rate', () => {
+        const input: Input = { taxableIncome: 30000 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.19);
+        expect(result.breakdowns[0].amount).toBe(5700);
+    });
+
+    it('returns breakdowns for main rate', () => {
+        const input: Input = { taxableIncome: 500000 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.25);
+        expect(result.breakdowns[0].amount).toBe(125000);
+    });
+
+    it('returns two breakdowns for marginal relief (main tax + relief)', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new UKCorporateTaxServiceImpl(input, ukCorporateRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(2);
+    });
+});

package/test/uk-income-tax.test.ts

@@ -0,0 +1,146 @@
+import { UKIncomeTaxServiceImpl } from '../src/income-tax/uk/UKIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/uk/domain/types';
+
+// UK 2024-25 income tax rules
+// Tax brackets are in terms of taxable income (after personal allowance deduction)
+const ukRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 37700, rate: 0.20 },       // Basic rate
+        { from: 37700, to: 125140, rate: 0.40 },   // Higher rate
+        { from: 125140, to: null, rate: 0.45 },    // Additional rate
+    ],
+    personalAllowance: {
+        amount: 12570,
+        taperThreshold: 100000,
+        taperRate: 0.5,
+    },
+    nationalInsurance: {
+        primaryThreshold: 12570,
+        upperEarningsLimit: 50270,
+        mainRate: 0.08,
+        upperRate: 0.02,
+    },
+};
+
+describe('UKIncomeTaxServiceImpl', () => {
+    it('returns zero tax for income at or below the personal allowance', () => {
+        const service = new UKIncomeTaxServiceImpl(12570, ukRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.grossIncome).toBe(12570);
+        expect(result.netIncome).toBe(result.grossIncome - result.totalDeductions);
+    });
+
+    it('correctly calculates income tax for £30,000 income', () => {
+        const service = new UKIncomeTaxServiceImpl(30000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // Personal allowance = £12,570
+        // Taxable income = 30000 - 12570 = 17430
+        // Tax = 17430 * 20% = 3486
+        expect(result.incomeTax).toBe(3486);
+        expect(result.personalAllowance).toBe(12570);
+    });
+
+    it('correctly calculates income tax for £50,000 income (basic rate only)', () => {
+        const service = new UKIncomeTaxServiceImpl(50000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // Taxable income = 50000 - 12570 = 37430
+        // Basic rate band: 37430 * 20% = 7486
+        expect(result.incomeTax).toBe(7486);
+    });
+
+    it('correctly calculates income tax for £60,000 income (higher rate applies)', () => {
+        const service = new UKIncomeTaxServiceImpl(60000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // Taxable income = 60000 - 12570 = 47430
+        // Basic rate: 37700 * 20% = 7540
+        // Higher rate: (47430 - 37700) * 40% = 9730 * 0.40 = 3892
+        // Total = 11432
+        expect(result.incomeTax).toBe(11432);
+    });
+
+    it('tapers personal allowance for income above £100,000', () => {
+        const service = new UKIncomeTaxServiceImpl(110000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // Personal allowance = 12570 - (110000 - 100000) * 0.5 = 12570 - 5000 = 7570
+        expect(result.personalAllowance).toBe(7570);
+    });
+
+    it('removes personal allowance entirely for income above £125,140', () => {
+        const service = new UKIncomeTaxServiceImpl(130000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // Personal allowance = max(0, 12570 - (130000 - 100000) * 0.5) = max(0, 12570 - 15000) = 0
+        expect(result.personalAllowance).toBe(0);
+    });
+
+    it('applies additional rate (45%) for income above £125,140 (after PA deducted)', () => {
+        const service = new UKIncomeTaxServiceImpl(150000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // No personal allowance (income > £125,140)
+        // Taxable income = 150000
+        // Basic rate: 37700 * 20% = 7540
+        // Higher rate: (125140 - 37700) * 40% = 87440 * 40% = 34976
+        // Additional rate: (150000 - 125140) * 45% = 24860 * 45% = 11187
+        // Total = 7540 + 34976 + 11187 = 53703
+        expect(result.incomeTax).toBe(53703);
+    });
+
+    it('calculates National Insurance correctly for basic rate taxpayer', () => {
+        const service = new UKIncomeTaxServiceImpl(30000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // NI: (30000 - 12570) * 8% = 17430 * 0.08 = 1394.40
+        expect(result.nationalInsurance).toBeCloseTo(1394.40, 2);
+    });
+
+    it('calculates National Insurance correctly above upper earnings limit', () => {
+        const service = new UKIncomeTaxServiceImpl(60000, ukRules);
+        const result = service.calculateNetIncome();
+
+        // NI main band: (50270 - 12570) * 8% = 37700 * 0.08 = 3016
+        // NI upper band: (60000 - 50270) * 2% = 9730 * 0.02 = 194.60
+        // Total NI = 3210.60
+        expect(result.nationalInsurance).toBeCloseTo(3210.60, 2);
+    });
+
+    it('returns zero National Insurance for income at or below primary threshold', () => {
+        const service = new UKIncomeTaxServiceImpl(12570, ukRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.nationalInsurance).toBe(0);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new UKIncomeTaxServiceImpl(50000, ukRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.netIncome).toBeCloseTo(
+            result.grossIncome - result.totalDeductions,
+            2,
+        );
+    });
+
+    it('effective tax rate is income tax divided by gross income', () => {
+        const service = new UKIncomeTaxServiceImpl(80000, ukRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(result.incomeTax / result.grossIncome, 4);
+    });
+
+    it('total deductions equals income tax plus National Insurance', () => {
+        const service = new UKIncomeTaxServiceImpl(50000, ukRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.totalDeductions).toBeCloseTo(
+            result.incomeTax + result.nationalInsurance,
+            2,
+        );
+    });
+});

package/test/uk-mortgage.test.ts

@@ -0,0 +1,154 @@
+import { UKMortgageServiceImpl } from '../src/mortgage/uk/UKMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/uk/domain/types';
+
+// UK 2024-25 mortgage rules
+const ukMortgageRules: MortgageRules = {
+    loanConstraints: {
+        maxLtvPercent: 95,
+        maxAmortizationYears: 35,
+    },
+    interest: {
+        compounding: 'MONTHLY',
+    },
+    stampDuty: {
+        standardBrackets: [
+            { upTo: 250000, rate: 0 },
+            { upTo: 925000, rate: 0.05 },
+            { upTo: 1500000, rate: 0.10 },
+            { above: 1500000, rate: 0.12 },
+        ],
+        firstTimeBuyer: {
+            brackets: [
+                { upTo: 425000, rate: 0 },
+                { upTo: 625000, rate: 0.05 },
+            ],
+            maxEligiblePropertyPrice: 625000,
+        },
+    },
+};
+
+const defaultInput: MortgageInput = {
+    propertyPrice: 400000,
+    downPayment: 80000, // 20% down
+    annualInterestRate: 5.0,
+    amortizationYears: 25,
+    isFirstTimeBuyer: false,
+};
+
+describe('UKMortgageServiceImpl', () => {
+    const service = new UKMortgageServiceImpl();
+
+    it('calculates loan amount correctly', () => {
+        const result = service.calculate(defaultInput, ukMortgageRules);
+
+        expect(result.loanAmount).toBe(320000);
+    });
+
+    it('calculates monthly payment using standard amortization formula', () => {
+        const result = service.calculate(defaultInput, ukMortgageRules);
+
+        const r = 0.05 / 12;
+        const n = 25 * 12;
+        const expected = 320000 * (r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1);
+        expect(result.monthlyPayment).toBeCloseTo(expected, 2);
+    });
+
+    it('totalPaid equals monthlyPayment * totalPayments', () => {
+        const result = service.calculate(defaultInput, ukMortgageRules);
+        const totalPayments = 25 * 12;
+
+        expect(result.totalPaid).toBeCloseTo(result.monthlyPayment * totalPayments, 0);
+    });
+
+    it('calculates standard SDLT at 0% for property at or below £250,000', () => {
+        const input: MortgageInput = {
+            ...defaultInput,
+            propertyPrice: 200000,
+            downPayment: 40000,
+        };
+        const result = service.calculate(input, ukMortgageRules);
+
+        expect(result.stampDuty).toBe(0);
+    });
+
+    it('calculates standard SDLT for property above £250,000', () => {
+        // 400000: 0% on 250000 = 0, 5% on (400000 - 250000) = 7500
+        const result = service.calculate(defaultInput, ukMortgageRules);
+
+        expect(result.stampDuty).toBe(7500);
+    });
+
+    it('calculates standard SDLT for property above £925,000', () => {
+        // 1000000: 0% on 250000 + 5% on 675000 + 10% on 75000
+        // = 0 + 33750 + 7500 = 41250
+        const input: MortgageInput = {
+            ...defaultInput,
+            propertyPrice: 1000000,
+            downPayment: 200000,
+        };
+        const result = service.calculate(input, ukMortgageRules);
+
+        expect(result.stampDuty).toBe(41250);
+    });
+
+    it('applies first-time buyer SDLT relief for eligible property', () => {
+        // First-time buyer, property = 500000
+        // 0% on first 425000 = 0, 5% on (500000 - 425000) = 3750
+        const input: MortgageInput = {
+            ...defaultInput,
+            propertyPrice: 500000,
+            downPayment: 100000,
+            isFirstTimeBuyer: true,
+        };
+        const result = service.calculate(input, ukMortgageRules);
+
+        expect(result.stampDuty).toBe(3750);
+    });
+
+    it('applies standard SDLT for first-time buyer on property above £625,000', () => {
+        // First-time buyer but property > 625000 → standard rates apply
+        const input: MortgageInput = {
+            ...defaultInput,
+            propertyPrice: 700000,
+            downPayment: 140000,
+            isFirstTimeBuyer: true,
+        };
+        const result = service.calculate(input, ukMortgageRules);
+
+        // Standard: 0% on 250000 = 0, 5% on 450000 = 22500
+        expect(result.stampDuty).toBe(22500);
+    });
+
+    it('throws error when loan amount is zero or negative', () => {
+        const input: MortgageInput = {
+            ...defaultInput,
+            downPayment: 400000,
+        };
+
+        expect(() => service.calculate(input, ukMortgageRules)).toThrow('Invalid loan amount');
+    });
+
+    it('generates amortization schedule with correct length', () => {
+        const result = service.calculate(defaultInput, ukMortgageRules);
+
+        expect(result.amortizationSchedule.length).toBe(25);
+        expect(result.amortizationSchedule[0].year).toBe(1);
+        expect(result.amortizationSchedule[24].balance).toBeCloseTo(0, 0);
+    });
+
+    it('amortization schedule balance decreases over time', () => {
+        const result = service.calculate(defaultInput, ukMortgageRules);
+        const schedule = result.amortizationSchedule;
+
+        for (let i = 1; i < schedule.length; i++) {
+            expect(schedule[i].balance).toBeLessThan(schedule[i - 1].balance);
+        }
+    });
+
+    it('otherFees includes stamp duty label', () => {
+        const result = service.calculate(defaultInput, ukMortgageRules);
+
+        expect(result.otherFees.notaryFees.label).toBe('STAMP_DUTY');
+        expect(result.otherFees.notaryFees.value).toBe(result.stampDuty);
+    });
+});