@novha/calc-engines 6.3.0 → 7.0.1

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();
+    });
+});

package/test/south-africa-inheritance-tax.test.ts

@@ -0,0 +1,81 @@
+import { SouthAfricaInheritanceTaxServiceImpl } from '../src/inheritance-tax/south-africa/SouthAfricaInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/south-africa/domain/types';
+
+const southAfricaRules: Rules = {
+    primaryAbatement: 3500000,
+    taxBrackets: [
+        { from: 0, to: 30000000, rate: 0.20 },
+        { from: 30000000, to: null, rate: 0.25 },
+    ],
+};
+
+describe('SouthAfricaInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for estate below primary abatement', () => {
+        const input: Input = { estateValue: 3000000, deductions: 0 };
+        const service = new SouthAfricaInheritanceTaxServiceImpl(input, southAfricaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('returns zero tax for estate at primary abatement', () => {
+        const input: Input = { estateValue: 3500000, deductions: 0 };
+        const service = new SouthAfricaInheritanceTaxServiceImpl(input, southAfricaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('applies 20% rate for estate above abatement within first bracket', () => {
+        const input: Input = { estateValue: 13500000, deductions: 0 };
+        const service = new SouthAfricaInheritanceTaxServiceImpl(input, southAfricaRules);
+        const result = service.calculate();
+
+        // Taxable = 13500000 - 3500000 = 10000000
+        // 10000000 * 0.20 = 2000000
+        expect(result.taxableEstate).toBe(10000000);
+        expect(result.inheritanceTax).toBe(2000000);
+    });
+
+    it('applies 25% rate for amounts above R30M bracket', () => {
+        const input: Input = { estateValue: 43500000, deductions: 0 };
+        const service = new SouthAfricaInheritanceTaxServiceImpl(input, southAfricaRules);
+        const result = service.calculate();
+
+        // Taxable = 43500000 - 3500000 = 40000000
+        // 30000000 * 0.20 = 6000000
+        // 10000000 * 0.25 = 2500000
+        // Total = 8500000
+        expect(result.taxableEstate).toBe(40000000);
+        expect(result.inheritanceTax).toBe(8500000);
+    });
+
+    it('deductions reduce taxable estate', () => {
+        const input: Input = { estateValue: 13500000, deductions: 5000000 };
+        const service = new SouthAfricaInheritanceTaxServiceImpl(input, southAfricaRules);
+        const result = service.calculate();
+
+        // Net estate = 13500000 - 5000000 = 8500000
+        // Taxable = 8500000 - 3500000 = 5000000
+        // 5000000 * 0.20 = 1000000
+        expect(result.taxableEstate).toBe(5000000);
+        expect(result.inheritanceTax).toBe(1000000);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, deductions: 0 };
+        const service = new SouthAfricaInheritanceTaxServiceImpl(input, southAfricaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 13500000, deductions: 0 };
+        const service = new SouthAfricaInheritanceTaxServiceImpl(input, southAfricaRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 13500000) * 100);
+    });
+});

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

@@ -0,0 +1,66 @@
+import { SpainCapitalGainsServiceImpl } from '../src/capital-gains/spain/SpainCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/spain/domain/types';
+
+const spainRules: Rules = {
+    brackets: [
+        { from: 0, to: 6000, rate: 0.19 },
+        { from: 6000, to: 50000, rate: 0.21 },
+        { from: 50000, to: 200000, rate: 0.23 },
+        { from: 200000, to: 300000, rate: 0.27 },
+        { from: 300000, to: null, rate: 0.30 },
+    ],
+};
+
+describe('SpainCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new SpainCapitalGainsServiceImpl(input, spainRules);
+        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 calculates tax for gain in first bracket', () => {
+        const input: Input = { capitalGain: 3000 };
+        const service = new SpainCapitalGainsServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        // 0-3000: 3000 * 0.19 = 570
+        expect(result.capitalGainTax).toBe(570);
+        expect(result.totalTax).toBe(570);
+        expect(result.effectiveRate).toBeCloseTo(19, 2);
+    });
+
+    it('correctly calculates tax spanning multiple brackets', () => {
+        const input: Input = { capitalGain: 100000 };
+        const service = new SpainCapitalGainsServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        // 0-6000: 6000 * 0.19 = 1140
+        // 6000-50000: 44000 * 0.21 = 9240
+        // 50000-100000: 50000 * 0.23 = 11500
+        // Total = 21880
+        expect(result.capitalGainTax).toBeCloseTo(21880, 2);
+        expect(result.totalTax).toBeCloseTo(21880, 2);
+    });
+
+    it('taxable gain equals input capital gain', () => {
+        const input: Input = { capitalGain: 50000 };
+        const service = new SpainCapitalGainsServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(50000);
+    });
+
+    it('effective rate equals total tax divided by gain times 100', () => {
+        const input: Input = { capitalGain: 100000 };
+        const service = new SpainCapitalGainsServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo((result.capitalGainTax / 100000) * 100, 2);
+    });
+});

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

@@ -0,0 +1,54 @@
+import { SpainCorporateTaxServiceImpl } from '../src/corporate/spain/SpainCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/spain/domain/types';
+
+const spainRules: Rules = {
+    regime: { type: 'flat', rate: 0.25 },
+};
+
+describe('SpainCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new SpainCorporateTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly applies the flat 25% rate', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new SpainCorporateTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        // 100000 * 0.25 = 25000
+        expect(result.corporateTax).toBe(25000);
+    });
+
+    it('calculates effective tax rate as percentage', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new SpainCorporateTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.effectiveTaxRate).toBe(25);
+    });
+
+    it('returns one breakdown entry for flat rate calculation', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new SpainCorporateTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.25);
+        expect(result.breakdowns[0].amount).toBe(25000);
+    });
+
+    it('scales linearly with taxable income', () => {
+        const input: Input = { taxableIncome: 500000 };
+        const service = new SpainCorporateTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.corporateTax).toBe(125000);
+        expect(result.effectiveTaxRate).toBe(25);
+    });
+});

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

@@ -0,0 +1,84 @@
+import { SpainIncomeTaxServiceImpl } from '../src/income-tax/spain/SpainIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/spain/domain/types';
+
+const spainRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 12450, rate: 0.19 },
+        { from: 12450, to: 20200, rate: 0.24 },
+        { from: 20200, to: 35200, rate: 0.30 },
+        { from: 35200, to: 60000, rate: 0.37 },
+        { from: 60000, to: 300000, rate: 0.45 },
+        { from: 300000, to: null, rate: 0.47 },
+    ],
+    socialContributions: { rate: 0.0635 },
+};
+
+describe('SpainIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new SpainIncomeTaxServiceImpl(0, spainRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.socialContributions).toBe(0);
+        expect(result.totalDeductions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('correctly calculates income tax for income in first bracket', () => {
+        const service = new SpainIncomeTaxServiceImpl(10000, spainRules);
+        const result = service.calculateNetIncome();
+
+        // 0-10000: 10000 * 0.19 = 1900
+        expect(result.incomeTax).toBeCloseTo(1900, 2);
+        expect(result.grossIncome).toBe(10000);
+    });
+
+    it('correctly calculates social contributions', () => {
+        const service = new SpainIncomeTaxServiceImpl(10000, spainRules);
+        const result = service.calculateNetIncome();
+
+        // 10000 * 0.0635 = 635
+        expect(result.socialContributions).toBeCloseTo(635, 2);
+    });
+
+    it('correctly calculates income tax spanning multiple brackets', () => {
+        const service = new SpainIncomeTaxServiceImpl(25000, spainRules);
+        const result = service.calculateNetIncome();
+
+        // 0-12450: 12450 * 0.19 = 2365.5
+        // 12450-20200: 7750 * 0.24 = 1860
+        // 20200-25000: 4800 * 0.30 = 1440
+        // Total = 5665.5
+        expect(result.incomeTax).toBeCloseTo(5665.5, 1);
+    });
+
+    it('calculates effective tax rate as income tax divided by gross income', () => {
+        const service = new SpainIncomeTaxServiceImpl(25000, spainRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(result.incomeTax / result.grossIncome, 4);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new SpainIncomeTaxServiceImpl(25000, spainRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('total deductions equals income tax plus social contributions', () => {
+        const service = new SpainIncomeTaxServiceImpl(25000, spainRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.totalDeductions).toBeCloseTo(result.incomeTax + result.socialContributions, 2);
+    });
+
+    it('applies highest bracket rate to income above 300000', () => {
+        const service = new SpainIncomeTaxServiceImpl(350000, spainRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBeGreaterThan(0);
+        const lastBreakdown = result.taxBracketBreakdown[result.taxBracketBreakdown.length - 1];
+        expect(lastBreakdown.rate).toBe(0.47);
+    });
+});