@novha/calc-engines 7.0.0 → 7.0.1

package/test/israel-mortgage.test.ts

@@ -0,0 +1,80 @@
+import { IsraelMortgageServiceImpl } from '../src/mortgage/israel/IsraelMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/israel/domain/types';
+
+const israelRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.75, maxAmortizationYears: 30 },
+    interest: { compounding: 'MONTHLY' },
+    purchaseTax: {
+        brackets: [
+            { upTo: 1978745, rate: 0 },
+            { upTo: 5872725, rate: 0.035 },
+            { upTo: 16140600, rate: 0.05 },
+            { upTo: 21520800, rate: 0.08 },
+            { above: 21520800, rate: 0.10 },
+        ],
+    },
+    landRegistrationFeeRate: 0.0025,
+};
+
+const input: MortgageInput = {
+    propertyPrice: 2000000,
+    downPayment: 500000,
+    annualInterestRate: 4.5,
+    amortizationYears: 25,
+    isFirstTimeBuyer: true,
+};
+
+describe('IsraelMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.loanAmount).toBe(1500000);
+    });
+
+    it('correctly calculates purchase tax for first-time buyer', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        // 0-1978745: 0% tax = 0
+        // 1978745-2000000: 21255 * 0.035 = 743.925
+        expect(result.purchaseTax).toBeCloseTo(743.93, 1);
+    });
+
+    it('correctly calculates land registration fee', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        // 2000000 * 0.0025 = 5000
+        expect(result.landRegistrationFee).toBeCloseTo(5000, 2);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const result = service.calculate(input, israelRules);
+        expect(result.amortizationSchedule).toHaveLength(25);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 2000000 };
+        expect(() => service.calculate(badInput, israelRules)).toThrow();
+    });
+
+    it('non-first-time buyer pays flat 8% purchase tax', () => {
+        const service = new IsraelMortgageServiceImpl();
+        const nonFtbInput: MortgageInput = { ...input, isFirstTimeBuyer: false };
+        const result = service.calculate(nonFtbInput, israelRules);
+        // 2000000 * 0.08 = 160000
+        expect(result.purchaseTax).toBeCloseTo(160000, 2);
+    });
+});

package/test/japan-capital-gains.test.ts

@@ -0,0 +1,55 @@
+import { JapanCapitalGainsServiceImpl } from '../src/capital-gains/japan/JapanCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/japan/domain/types';
+
+const japanRules: Rules = {
+    flatRate: 0.20315,
+};
+
+describe('JapanCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(0);
+        expect(result.capitalGainTax).toBe(0);
+        expect(result.totalTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly applies the flat 20.315% rate', () => {
+        const input: Input = { capitalGain: 1000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        // 1000000 * 0.20315 = 203150
+        expect(result.capitalGainTax).toBeCloseTo(203150, 2);
+        expect(result.totalTax).toBeCloseTo(203150, 2);
+    });
+
+    it('effective rate equals the flat rate as a percentage', () => {
+        const input: Input = { capitalGain: 1000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo(20.315, 3);
+    });
+
+    it('returns one breakdown entry for flat rate calculation', () => {
+        const input: Input = { capitalGain: 1000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.20315);
+    });
+
+    it('scales linearly with capital gain', () => {
+        const input: Input = { capitalGain: 5000000 };
+        const service = new JapanCapitalGainsServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.capitalGainTax).toBeCloseTo(5000000 * 0.20315, 2);
+    });
+});

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

@@ -0,0 +1,54 @@
+import { JapanCorporateTaxServiceImpl } from '../src/corporate/japan/JapanCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/japan/domain/types';
+
+const japanRules: Rules = {
+    regime: { type: 'flat', rate: 0.335 },
+};
+
+describe('JapanCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly applies the flat 33.5% rate', () => {
+        const input: Input = { taxableIncome: 10000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        // 10000000 * 0.335 = 3350000
+        expect(result.corporateTax).toBe(3350000);
+    });
+
+    it('calculates effective tax rate as percentage', () => {
+        const input: Input = { taxableIncome: 10000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.effectiveTaxRate).toBe(33.5);
+    });
+
+    it('returns one breakdown entry for flat rate calculation', () => {
+        const input: Input = { taxableIncome: 10000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.335);
+        expect(result.breakdowns[0].amount).toBe(3350000);
+    });
+
+    it('scales linearly with taxable income', () => {
+        const input: Input = { taxableIncome: 1000000 };
+        const service = new JapanCorporateTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(335000);
+        expect(result.effectiveTaxRate).toBe(33.5);
+    });
+});

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

@@ -0,0 +1,76 @@
+import { JapanIncomeTaxServiceImpl } from '../src/income-tax/japan/JapanIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/japan/domain/types';
+
+const japanRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 1950000, rate: 0.05 },
+        { from: 1950000, to: 3300000, rate: 0.10 },
+        { from: 3300000, to: 6950000, rate: 0.20 },
+        { from: 6950000, to: 9000000, rate: 0.23 },
+        { from: 9000000, to: 18000000, rate: 0.33 },
+        { from: 18000000, to: 40000000, rate: 0.40 },
+        { from: 40000000, to: null, rate: 0.45 },
+    ],
+    inhabitantTax: { rate: 0.10 },
+};
+
+describe('JapanIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new JapanIncomeTaxServiceImpl(0, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.nationalIncomeTax).toBe(0);
+        expect(result.inhabitantTax).toBe(0);
+        expect(result.totalDeductions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('correctly calculates national income tax for income in first bracket', () => {
+        const service = new JapanIncomeTaxServiceImpl(1000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        // 0-1000000: 1000000 * 0.05 = 50000
+        expect(result.nationalIncomeTax).toBeCloseTo(50000, 2);
+        expect(result.grossIncome).toBe(1000000);
+    });
+
+    it('correctly calculates inhabitant tax as a flat rate on gross income', () => {
+        const service = new JapanIncomeTaxServiceImpl(1000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        // inhabitantTax = 1000000 * 0.10 = 100000
+        expect(result.inhabitantTax).toBeCloseTo(100000, 2);
+    });
+
+    it('correctly calculates income spanning multiple brackets', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        // 0-1950000: 1950000 * 0.05 = 97500
+        // 1950000-3300000: 1350000 * 0.10 = 135000
+        // 3300000-5000000: 1700000 * 0.20 = 340000
+        // Total = 572500
+        expect(result.nationalIncomeTax).toBeCloseTo(572500, 2);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('total deductions equals national income tax plus inhabitant tax', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.totalDeductions).toBeCloseTo(result.nationalIncomeTax + result.inhabitantTax, 2);
+    });
+
+    it('calculates effective tax rate as national income tax divided by gross income', () => {
+        const service = new JapanIncomeTaxServiceImpl(5000000, japanRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(result.nationalIncomeTax / result.grossIncome, 4);
+    });
+});

package/test/japan-inheritance-tax.test.ts

@@ -0,0 +1,74 @@
+import { JapanInheritanceTaxServiceImpl } from '../src/inheritance-tax/japan/JapanInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/japan/domain/types';
+
+const japanRules: Rules = {
+    baseExemption: 30000000,
+    perHeirExemption: 6000000,
+    taxBrackets: [
+        { from: 0, to: 10000000, rate: 0.10 },
+        { from: 10000000, to: 30000000, rate: 0.15 },
+        { from: 30000000, to: 50000000, rate: 0.20 },
+        { from: 50000000, to: 100000000, rate: 0.30 },
+        { from: 100000000, to: 200000000, rate: 0.40 },
+        { from: 200000000, to: 300000000, rate: 0.45 },
+        { from: 300000000, to: 600000000, rate: 0.50 },
+        { from: 600000000, to: null, rate: 0.55 },
+    ],
+};
+
+describe('JapanInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for zero estate', () => {
+        const input: Input = { estateValue: 0, numberOfStatutoryHeirs: 1 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+    });
+
+    it('returns zero tax when estate is below the total exemption (1 heir)', () => {
+        // 1 heir: exemption = 30000000 + 6000000 * 1 = 36000000
+        // estate = 35000000 < 36000000 → no tax
+        const input: Input = { estateValue: 35000000, numberOfStatutoryHeirs: 1 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates tax for estate above the exemption (2 heirs)', () => {
+        // 2 heirs: exemption = 30000000 + 6000000 * 2 = 42000000
+        // taxable = 100000000 - 42000000 = 58000000
+        // 0-10000000: 10000000 * 0.10 = 1000000
+        // 10000000-30000000: 20000000 * 0.15 = 3000000
+        // 30000000-50000000: 20000000 * 0.20 = 4000000
+        // 50000000-58000000: 8000000 * 0.30 = 2400000
+        // Total = 10400000
+        const input: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 2 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.taxableEstate).toBe(58000000);
+        expect(result.inheritanceTax).toBeCloseTo(10400000, 2);
+    });
+
+    it('effective rate equals inheritance tax divided by estate times 100', () => {
+        const input: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 2 };
+        const service = new JapanInheritanceTaxServiceImpl(input, japanRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo((result.inheritanceTax / 100000000) * 100, 2);
+    });
+
+    it('more heirs increases the exemption and reduces taxable estate', () => {
+        const input1: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 1 };
+        const input3: Input = { estateValue: 100000000, numberOfStatutoryHeirs: 3 };
+
+        const tax1 = new JapanInheritanceTaxServiceImpl(input1, japanRules).calculate().inheritanceTax;
+        const tax3 = new JapanInheritanceTaxServiceImpl(input3, japanRules).calculate().inheritanceTax;
+
+        expect(tax3).toBeLessThan(tax1);
+    });
+});

package/test/japan-mortgage.test.ts

@@ -0,0 +1,69 @@
+import { JapanMortgageServiceImpl } from '../src/mortgage/japan/JapanMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/japan/domain/types';
+
+const japanRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.80, maxAmortizationYears: 35 },
+    interest: { compounding: 'MONTHLY' },
+    acquisitionTax: { rate: 0.03 },
+};
+
+const input: MortgageInput = {
+    propertyPrice: 50000000,
+    downPayment: 10000000,
+    annualInterestRate: 1.5,
+    amortizationYears: 30,
+    isFirstTimeBuyer: false,
+};
+
+describe('JapanMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new JapanMortgageServiceImpl();
+        const result = service.calculate(input, japanRules);
+
+        // loanAmount = 50000000 - 10000000 = 40000000
+        expect(result.loanAmount).toBe(40000000);
+    });
+
+    it('correctly calculates acquisition tax', () => {
+        const service = new JapanMortgageServiceImpl();
+        const result = service.calculate(input, japanRules);
+
+        // acquisitionTax = 50000000 * 0.03 = 1500000
+        expect(result.acquisitionTax).toBe(1500000);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new JapanMortgageServiceImpl();
+        const result = service.calculate(input, japanRules);
+
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new JapanMortgageServiceImpl();
+        const result = service.calculate(input, japanRules);
+
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('total interest paid equals total paid minus loan amount', () => {
+        const service = new JapanMortgageServiceImpl();
+        const result = service.calculate(input, japanRules);
+
+        expect(result.totalInterestPaid).toBeCloseTo(result.totalPaid - result.loanAmount, 2);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new JapanMortgageServiceImpl();
+        const result = service.calculate(input, japanRules);
+
+        expect(result.amortizationSchedule).toHaveLength(30);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new JapanMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 50000000 };
+
+        expect(() => service.calculate(badInput, japanRules)).toThrow();
+    });
+});

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

@@ -0,0 +1,54 @@
+import { NetherlandsCorporateTaxServiceImpl } from '../src/corporate/netherlands/NetherlandsCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/netherlands/domain/types';
+
+const netherlandsRules: Rules = {
+    tiers: [
+        { from: 0, to: 200000, rate: 0.19 },
+        { from: 200000, to: null, rate: 0.258 },
+    ],
+};
+
+describe('NetherlandsCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new NetherlandsCorporateTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly calculates tax for income within first tier (19%)', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new NetherlandsCorporateTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        // 100000 * 0.19 = 19000
+        expect(result.corporateTax).toBe(19000);
+        expect(result.effectiveTaxRate).toBe(19);
+    });
+
+    it('correctly calculates tax spanning both tiers', () => {
+        const input: Input = { taxableIncome: 300000 };
+        const service = new NetherlandsCorporateTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        // 0-200000: 200000 * 0.19 = 38000
+        // 200000-300000: 100000 * 0.258 = 25800
+        // Total = 63800
+        expect(result.corporateTax).toBe(63800);
+    });
+
+    it('returns two breakdown entries when spanning both tiers', () => {
+        const input: Input = { taxableIncome: 300000 };
+        const service = new NetherlandsCorporateTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        expect(result.breakdowns).toHaveLength(2);
+    });
+
+    it('effective tax rate is less than top rate for income spanning tiers', () => {
+        const input: Input = { taxableIncome: 300000 };
+        const service = new NetherlandsCorporateTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        expect(result.effectiveTaxRate).toBeLessThan(25.8);
+        expect(result.effectiveTaxRate).toBeGreaterThan(19);
+    });
+});

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

@@ -0,0 +1,54 @@
+import { NetherlandsIncomeTaxServiceImpl } from '../src/income-tax/netherlands/NetherlandsIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/netherlands/domain/types';
+
+const netherlandsRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 75624, rate: 0.3697 },
+        { from: 75624, to: null, rate: 0.495 },
+    ],
+    socialContributions: { rate: 0 },
+};
+
+describe('NetherlandsIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new NetherlandsIncomeTaxServiceImpl(0, netherlandsRules);
+        const result = service.calculateNetIncome();
+        expect(result.incomeTax).toBe(0);
+        expect(result.socialContributions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('correctly calculates income tax in first bracket', () => {
+        const service = new NetherlandsIncomeTaxServiceImpl(50000, netherlandsRules);
+        const result = service.calculateNetIncome();
+        // 50000 * 0.3697 = 18485
+        expect(result.incomeTax).toBeCloseTo(18485, 2);
+    });
+
+    it('correctly calculates income tax spanning both brackets', () => {
+        const service = new NetherlandsIncomeTaxServiceImpl(100000, netherlandsRules);
+        const result = service.calculateNetIncome();
+        // 0-75624: 75624 * 0.3697 = 27958.19
+        // 75624-100000: 24376 * 0.495 = 12066.12
+        // Total ≈ 40024.31
+        expect(result.incomeTax).toBeCloseTo(40024.31, 1);
+    });
+
+    it('social contributions are zero (included in brackets)', () => {
+        const service = new NetherlandsIncomeTaxServiceImpl(50000, netherlandsRules);
+        const result = service.calculateNetIncome();
+        expect(result.socialContributions).toBe(0);
+    });
+
+    it('net income equals gross income minus income tax', () => {
+        const service = new NetherlandsIncomeTaxServiceImpl(50000, netherlandsRules);
+        const result = service.calculateNetIncome();
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('effective tax rate calculation is correct', () => {
+        const service = new NetherlandsIncomeTaxServiceImpl(50000, netherlandsRules);
+        const result = service.calculateNetIncome();
+        expect(result.effectiveTaxRate).toBeCloseTo(result.incomeTax / result.grossIncome, 4);
+    });
+});

package/test/netherlands-inheritance-tax.test.ts

@@ -0,0 +1,79 @@
+import { NetherlandsInheritanceTaxServiceImpl } from '../src/inheritance-tax/netherlands/NetherlandsInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/netherlands/domain/types';
+
+const netherlandsRules: Rules = {
+    taxClasses: {
+        Partner: {
+            exemption: 795156,
+            brackets: [
+                { from: 0, to: 138642, rate: 0.10 },
+                { from: 138642, to: null, rate: 0.20 },
+            ],
+        },
+        Child: {
+            exemption: 25187,
+            brackets: [
+                { from: 0, to: 138642, rate: 0.10 },
+                { from: 138642, to: null, rate: 0.20 },
+            ],
+        },
+        Other: {
+            exemption: 2658,
+            brackets: [
+                { from: 0, to: 138642, rate: 0.30 },
+                { from: 138642, to: null, rate: 0.40 },
+            ],
+        },
+    },
+};
+
+describe('NetherlandsInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for Partner estate below exemption', () => {
+        const input: Input = { estateValue: 500000, taxClass: 'Partner' };
+        const service = new NetherlandsInheritanceTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates Partner tax for estate above exemption', () => {
+        const input: Input = { estateValue: 933798, taxClass: 'Partner' }; // 138642 above exemption
+        const service = new NetherlandsInheritanceTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        // 138642 * 0.10 = 13864.2
+        expect(result.taxableEstate).toBe(138642);
+        expect(result.inheritanceTax).toBeCloseTo(13864.2, 2);
+    });
+
+    it('correctly calculates Child tax with lower exemption', () => {
+        const input: Input = { estateValue: 125187, taxClass: 'Child' }; // 100000 above exemption
+        const service = new NetherlandsInheritanceTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        // 100000 * 0.10 = 10000
+        expect(result.taxableEstate).toBe(100000);
+        expect(result.inheritanceTax).toBe(10000);
+    });
+
+    it('correctly calculates Other class with higher rates', () => {
+        const input: Input = { estateValue: 102658, taxClass: 'Other' }; // 100000 above exemption
+        const service = new NetherlandsInheritanceTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        // 100000 * 0.30 = 30000
+        expect(result.taxableEstate).toBe(100000);
+        expect(result.inheritanceTax).toBe(30000);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, taxClass: 'Child' };
+        const service = new NetherlandsInheritanceTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 1000000, taxClass: 'Child' };
+        const service = new NetherlandsInheritanceTaxServiceImpl(input, netherlandsRules);
+        const result = service.calculate();
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 1000000) * 100);
+    });
+});

package/test/netherlands-mortgage.test.ts

@@ -0,0 +1,79 @@
+import { NetherlandsMortgageServiceImpl } from '../src/mortgage/netherlands/NetherlandsMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/netherlands/domain/types';
+
+const netherlandsRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 1.0, maxAmortizationYears: 30 },
+    interest: { compounding: 'MONTHLY' },
+    transferTax: { primaryResidenceRate: 0.02, otherRate: 0.104 },
+    notaryFeeRate: 0.004,
+    landRegistryFeeRate: 0.001,
+};
+
+const input: MortgageInput = {
+    propertyPrice: 400000,
+    downPayment: 40000,
+    annualInterestRate: 3.0,
+    amortizationYears: 30,
+    isPrimaryResidence: true,
+};
+
+describe('NetherlandsMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const result = service.calculate(input, netherlandsRules);
+        expect(result.loanAmount).toBe(360000);
+    });
+
+    it('correctly calculates transfer tax for primary residence', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const result = service.calculate(input, netherlandsRules);
+        // 400000 * 0.02 = 8000
+        expect(result.transferTax).toBeCloseTo(8000, 2);
+    });
+
+    it('correctly calculates transfer tax for non-primary residence', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const nonPrimaryInput: MortgageInput = { ...input, isPrimaryResidence: false };
+        const result = service.calculate(nonPrimaryInput, netherlandsRules);
+        // 400000 * 0.104 = 41600
+        expect(result.transferTax).toBeCloseTo(41600, 2);
+    });
+
+    it('correctly calculates notary fees', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const result = service.calculate(input, netherlandsRules);
+        // 400000 * 0.004 = 1600
+        expect(result.notaryFees).toBeCloseTo(1600, 2);
+    });
+
+    it('correctly calculates land registry fee', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const result = service.calculate(input, netherlandsRules);
+        // 400000 * 0.001 = 400
+        expect(result.landRegistryFee).toBeCloseTo(400, 2);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const result = service.calculate(input, netherlandsRules);
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const result = service.calculate(input, netherlandsRules);
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const result = service.calculate(input, netherlandsRules);
+        expect(result.amortizationSchedule).toHaveLength(30);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new NetherlandsMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 400000 };
+        expect(() => service.calculate(badInput, netherlandsRules)).toThrow();
+    });
+});