@novha/calc-engines 7.0.0 → 8.0.0

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

@@ -0,0 +1,78 @@
+import { IndiaIncomeTaxServiceImpl } from '../src/income-tax/india/IndiaIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/india/domain/types';
+
+const indiaRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 300000, rate: 0 },
+        { from: 300000, to: 700000, rate: 0.05 },
+        { from: 700000, to: 1000000, rate: 0.10 },
+        { from: 1000000, to: 1200000, rate: 0.15 },
+        { from: 1200000, to: 1500000, rate: 0.20 },
+        { from: 1500000, to: null, rate: 0.30 },
+    ],
+    cess: { rate: 0.04 },
+};
+
+describe('IndiaIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new IndiaIncomeTaxServiceImpl(0, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.cess).toBe(0);
+        expect(result.totalDeductions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('returns zero income tax for income below the basic exemption (300000)', () => {
+        const service = new IndiaIncomeTaxServiceImpl(200000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.cess).toBe(0);
+        expect(result.grossIncome).toBe(200000);
+    });
+
+    it('correctly calculates tax and cess for income spanning multiple brackets', () => {
+        const service = new IndiaIncomeTaxServiceImpl(800000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        // 0-300000: 0 tax
+        // 300000-700000: 400000 * 0.05 = 20000
+        // 700000-800000: 100000 * 0.10 = 10000
+        // grossTax = 30000
+        // cess = 30000 * 0.04 = 1200
+        expect(result.incomeTax).toBeCloseTo(30000, 2);
+        expect(result.cess).toBeCloseTo(1200, 2);
+    });
+
+    it('correctly calculates total deductions as income tax plus cess', () => {
+        const service = new IndiaIncomeTaxServiceImpl(800000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.totalDeductions).toBeCloseTo(result.incomeTax + result.cess, 2);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new IndiaIncomeTaxServiceImpl(800000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('calculates effective tax rate as income tax divided by gross income', () => {
+        const service = new IndiaIncomeTaxServiceImpl(1000000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.effectiveTaxRate).toBeCloseTo(result.incomeTax / result.grossIncome, 4);
+    });
+
+    it('correctly applies the top bracket for high income', () => {
+        const service = new IndiaIncomeTaxServiceImpl(2000000, indiaRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBeGreaterThan(0);
+        const lastBreakdown = result.taxBracketBreakdown[result.taxBracketBreakdown.length - 1];
+        expect(lastBreakdown.rate).toBe(0.30);
+    });
+});

package/test/india-mortgage.test.ts

@@ -0,0 +1,70 @@
+import { IndiaMortgageServiceImpl } from '../src/mortgage/india/IndiaMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/india/domain/types';
+
+const indiaRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.75, maxAmortizationYears: 30 },
+    interest: { compounding: 'MONTHLY' },
+    stampDuty: { rate: 0.05 },
+};
+
+const input: MortgageInput = {
+    propertyPrice: 10000000,
+    downPayment: 2000000,
+    annualInterestRate: 8.5,
+    amortizationYears: 20,
+    isFirstTimeBuyer: false,
+};
+
+describe('IndiaMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        // loanAmount = 10000000 - 2000000 = 8000000
+        expect(result.loanAmount).toBe(8000000);
+    });
+
+    it('correctly calculates stamp duty', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        // stampDuty = 10000000 * 0.05 = 500000
+        expect(result.stampDuty).toBe(500000);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        expect(result.amortizationSchedule).toHaveLength(20);
+    });
+
+    it('total paid equals monthly payment multiplied by total payments', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const result = service.calculate(input, indiaRules);
+
+        const expectedTotal = result.monthlyPayment * (input.amortizationYears * 12);
+        expect(result.totalPaid).toBeCloseTo(expectedTotal, 2);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new IndiaMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 10000000 };
+
+        expect(() => service.calculate(badInput, indiaRules)).toThrow();
+    });
+});

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