@novha/calc-engines 6.3.0 → 7.0.1

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

@@ -0,0 +1,65 @@
+import { BrazilCapitalGainsServiceImpl } from '../src/capital-gains/brazil/BrazilCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/brazil/domain/types';
+
+const brazilRules: Rules = {
+    brackets: [
+        { from: 0, to: 5000000, rate: 0.15 },
+        { from: 5000000, to: 10000000, rate: 0.175 },
+        { from: 10000000, to: 30000000, rate: 0.20 },
+        { from: 30000000, to: null, rate: 0.225 },
+    ],
+};
+
+describe('BrazilCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        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: 1000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // 0-1000000: 1000000 * 0.15 = 150000
+        expect(result.capitalGainTax).toBe(150000);
+        expect(result.totalTax).toBe(150000);
+        expect(result.effectiveRate).toBeCloseTo(15, 2);
+    });
+
+    it('correctly calculates tax spanning multiple brackets', () => {
+        const input: Input = { capitalGain: 7000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // 0-5000000: 5000000 * 0.15 = 750000
+        // 5000000-7000000: 2000000 * 0.175 = 350000
+        // Total = 1100000
+        expect(result.capitalGainTax).toBeCloseTo(1100000, 2);
+        expect(result.totalTax).toBeCloseTo(1100000, 2);
+        expect(result.effectiveRate).toBeCloseTo((1100000 / 7000000) * 100, 2);
+    });
+
+    it('taxable gain equals input capital gain', () => {
+        const input: Input = { capitalGain: 3000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(3000000);
+    });
+
+    it('returns correct number of breakdown entries', () => {
+        const input: Input = { capitalGain: 7000000 };
+        const service = new BrazilCapitalGainsServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(2);
+    });
+});

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

@@ -0,0 +1,63 @@
+import { BrazilCorporateTaxServiceImpl } from '../src/corporate/brazil/BrazilCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/brazil/domain/types';
+
+const brazilRules: Rules = {
+    irpj: { baseRate: 0.15, surchargeRate: 0.10, surchargeThreshold: 240000 },
+    csll: { rate: 0.09 },
+};
+
+describe('BrazilCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        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 below the surcharge threshold', () => {
+        const input: Input = { taxableIncome: 200000 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // IRPJ base: 200000 * 0.15 = 30000
+        // Surcharge: 0 (200000 <= 240000)
+        // CSLL: 200000 * 0.09 = 18000
+        // Total = 48000
+        expect(result.corporateTax).toBeCloseTo(48000, 2);
+        expect(result.effectiveTaxRate).toBeCloseTo(24, 2);
+    });
+
+    it('correctly calculates tax for income above the surcharge threshold', () => {
+        const input: Input = { taxableIncome: 400000 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        // IRPJ base: 400000 * 0.15 = 60000
+        // Surcharge: (400000 - 240000) * 0.10 = 16000
+        // CSLL: 400000 * 0.09 = 36000
+        // Total = 112000
+        expect(result.corporateTax).toBeCloseTo(112000, 2);
+        expect(result.effectiveTaxRate).toBeCloseTo(28, 2);
+    });
+
+    it('returns three breakdown entries when surcharge applies', () => {
+        const input: Input = { taxableIncome: 400000 };
+        const service = new BrazilCorporateTaxServiceImpl(input, brazilRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(3);
+    });
+
+    it('effective tax rate is higher when income exceeds surcharge threshold', () => {
+        const inputBelow: Input = { taxableIncome: 200000 };
+        const inputAbove: Input = { taxableIncome: 400000 };
+
+        const rateBelow = new BrazilCorporateTaxServiceImpl(inputBelow, brazilRules).calculate().effectiveTaxRate;
+        const rateAbove = new BrazilCorporateTaxServiceImpl(inputAbove, brazilRules).calculate().effectiveTaxRate;
+
+        expect(rateAbove).toBeGreaterThan(rateBelow);
+    });
+});

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

@@ -0,0 +1,85 @@
+import { BrazilIncomeTaxServiceImpl } from '../src/income-tax/brazil/BrazilIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/brazil/domain/types';
+
+const brazilRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 27110.40, rate: 0 },
+        { from: 27110.40, to: 33919.80, rate: 0.075 },
+        { from: 33919.80, to: 45012.60, rate: 0.15 },
+        { from: 45012.60, to: 55976.16, rate: 0.225 },
+        { from: 55976.16, to: null, rate: 0.275 },
+    ],
+    inss: { rate: 0.11, cap: 87600 },
+};
+
+describe('BrazilIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new BrazilIncomeTaxServiceImpl(0, brazilRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.inss).toBe(0);
+        expect(result.totalDeductions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('returns zero income tax for income in first bracket (below 27110.40)', () => {
+        const service = new BrazilIncomeTaxServiceImpl(20000, brazilRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.incomeTax).toBe(0);
+        expect(result.grossIncome).toBe(20000);
+        // INSS = 20000 * 0.11 = 2200
+        expect(result.inss).toBeCloseTo(2200, 2);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('correctly calculates income tax for income spanning multiple brackets', () => {
+        const service = new BrazilIncomeTaxServiceImpl(50000, brazilRules);
+        const result = service.calculateNetIncome();
+
+        // 0-27110.40: 0 tax
+        // 27110.40-33919.80: 6809.40 * 0.075 = 510.705
+        // 33919.80-45012.60: 11092.80 * 0.15 = 1663.92
+        // 45012.60-50000: 4987.40 * 0.225 = 1122.165
+        // Total ≈ 3296.79
+        expect(result.incomeTax).toBeCloseTo(3296.79, 1);
+        expect(result.grossIncome).toBe(50000);
+    });
+
+    it('correctly computes INSS and caps it at the cap amount', () => {
+        const service = new BrazilIncomeTaxServiceImpl(100000, brazilRules);
+        const result = service.calculateNetIncome();
+
+        // INSS is capped at 87600: 87600 * 0.11 = 9636
+        expect(result.inss).toBeCloseTo(9636, 2);
+    });
+
+    it('calculates effective tax rate as income tax divided by gross income', () => {
+        const service = new BrazilIncomeTaxServiceImpl(50000, brazilRules);
+        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 BrazilIncomeTaxServiceImpl(50000, brazilRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('total deductions equals income tax plus INSS', () => {
+        const service = new BrazilIncomeTaxServiceImpl(50000, brazilRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.totalDeductions).toBeCloseTo(result.incomeTax + result.inss, 2);
+    });
+
+    it('returns bracket breakdown entries for multi-bracket income', () => {
+        const service = new BrazilIncomeTaxServiceImpl(60000, brazilRules);
+        const result = service.calculateNetIncome();
+
+        expect(result.taxBracketBreakdown.length).toBeGreaterThan(0);
+    });
+});

package/test/brazil-mortgage.test.ts

@@ -0,0 +1,70 @@
+import { BrazilMortgageServiceImpl } from '../src/mortgage/brazil/BrazilMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/brazil/domain/types';
+
+const brazilRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.80, maxAmortizationYears: 35 },
+    interest: { compounding: 'MONTHLY' },
+    itbi: { rate: 0.02 },
+};
+
+const input: MortgageInput = {
+    propertyPrice: 500000,
+    downPayment: 100000,
+    annualInterestRate: 10,
+    amortizationYears: 30,
+    isFirstTimeBuyer: false,
+};
+
+describe('BrazilMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new BrazilMortgageServiceImpl();
+        const result = service.calculate(input, brazilRules);
+
+        // loanAmount = 500000 - 100000 = 400000
+        expect(result.loanAmount).toBe(400000);
+    });
+
+    it('correctly calculates ITBI', () => {
+        const service = new BrazilMortgageServiceImpl();
+        const result = service.calculate(input, brazilRules);
+
+        // ITBI = 500000 * 0.02 = 10000
+        expect(result.itbi).toBe(10000);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new BrazilMortgageServiceImpl();
+        const result = service.calculate(input, brazilRules);
+
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new BrazilMortgageServiceImpl();
+        const result = service.calculate(input, brazilRules);
+
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new BrazilMortgageServiceImpl();
+        const result = service.calculate(input, brazilRules);
+
+        expect(result.amortizationSchedule).toHaveLength(30);
+    });
+
+    it('total paid equals monthly payment multiplied by total payments', () => {
+        const service = new BrazilMortgageServiceImpl();
+        const result = service.calculate(input, brazilRules);
+
+        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 BrazilMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 500000 };
+
+        expect(() => service.calculate(badInput, brazilRules)).toThrow();
+    });
+});

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

@@ -0,0 +1,62 @@
+import { CanadaInheritanceTaxServiceImpl } from '../src/inheritance-tax/canada/CanadaInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/canada/domain/types';
+
+const canadaRules: Rules = {
+    inclusionRate: 0.50,
+    taxBrackets: [
+        { from: 0, to: 55867, rate: 0.15 },
+        { from: 55867, to: 111733, rate: 0.205 },
+        { from: 111733, to: 154906, rate: 0.26 },
+        { from: 154906, to: 220000, rate: 0.29 },
+        { from: 220000, to: null, rate: 0.33 },
+    ],
+};
+
+describe('CanadaInheritanceTaxServiceImpl', () => {
+    it('returns zero tax when no capital gain (estate = cost base)', () => {
+        const input: Input = { estateValue: 500000, adjustedCostBase: 500000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('returns zero tax when estate is below cost base', () => {
+        const input: Input = { estateValue: 300000, adjustedCostBase: 500000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('correctly calculates tax on capital gain at death', () => {
+        const input: Input = { estateValue: 600000, adjustedCostBase: 400000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        // Gain = 200000, taxable gain = 200000 * 0.5 = 100000
+        // 55867 * 0.15 = 8380.05
+        // (100000 - 55867) * 0.205 = 44133 * 0.205 = 9047.265
+        // Total ≈ 17427.315
+        expect(result.taxableEstate).toBe(100000);
+        expect(result.inheritanceTax).toBeCloseTo(17427.315, 2);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, adjustedCostBase: 0 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate based on total gain', () => {
+        const input: Input = { estateValue: 600000, adjustedCostBase: 400000 };
+        const service = new CanadaInheritanceTaxServiceImpl(input, canadaRules);
+        const result = service.calculate();
+
+        // Effective rate is relative to the gain (200000), not the included portion
+        expect(result.effectiveRate).toBeCloseTo((result.inheritanceTax / 200000) * 100, 2);
+    });
+});

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

@@ -0,0 +1,101 @@
+import { FranceInheritanceTaxServiceImpl } from '../src/inheritance-tax/france/FranceInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/france/domain/types';
+
+const franceRules: Rules = {
+    relationships: {
+        spouse: {
+            exemption: Infinity,
+            brackets: [],
+        },
+        child: {
+            exemption: 100000,
+            brackets: [
+                { from: 0, to: 8072, rate: 0.05 },
+                { from: 8072, to: 12109, rate: 0.10 },
+                { from: 12109, to: 15932, rate: 0.15 },
+                { from: 15932, to: 552324, rate: 0.20 },
+                { from: 552324, to: 902838, rate: 0.30 },
+                { from: 902838, to: 1805677, rate: 0.40 },
+                { from: 1805677, to: null, rate: 0.45 },
+            ],
+        },
+        sibling: {
+            exemption: 15932,
+            brackets: [
+                { from: 0, to: 24430, rate: 0.35 },
+                { from: 24430, to: null, rate: 0.45 },
+            ],
+        },
+        other: {
+            exemption: 1594,
+            brackets: [
+                { from: 0, to: null, rate: 0.60 },
+            ],
+        },
+    },
+};
+
+describe('FranceInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for spouse inheritance', () => {
+        const input: Input = { estateValue: 5000000, relationship: 'spouse' };
+        const service = new FranceInheritanceTaxServiceImpl(input, franceRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('returns zero tax for child inheritance below exemption', () => {
+        const input: Input = { estateValue: 80000, relationship: 'child' };
+        const service = new FranceInheritanceTaxServiceImpl(input, franceRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('correctly calculates child inheritance tax above exemption', () => {
+        const input: Input = { estateValue: 108072, relationship: 'child' }; // 8072 above exemption
+        const service = new FranceInheritanceTaxServiceImpl(input, franceRules);
+        const result = service.calculate();
+
+        // 8072 * 0.05 = 403.60
+        expect(result.taxableEstate).toBe(8072);
+        expect(result.inheritanceTax).toBeCloseTo(403.60, 2);
+    });
+
+    it('applies higher rates for sibling inheritance', () => {
+        const input: Input = { estateValue: 40362, relationship: 'sibling' }; // 24430 above exemption
+        const service = new FranceInheritanceTaxServiceImpl(input, franceRules);
+        const result = service.calculate();
+
+        // 24430 * 0.35 = 8550.50
+        expect(result.taxableEstate).toBe(24430);
+        expect(result.inheritanceTax).toBeCloseTo(8550.50, 2);
+    });
+
+    it('applies 60% flat rate for unrelated persons', () => {
+        const input: Input = { estateValue: 101594, relationship: 'other' }; // 100000 above exemption
+        const service = new FranceInheritanceTaxServiceImpl(input, franceRules);
+        const result = service.calculate();
+
+        // 100000 * 0.60 = 60000
+        expect(result.taxableEstate).toBe(100000);
+        expect(result.inheritanceTax).toBe(60000);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, relationship: 'child' };
+        const service = new FranceInheritanceTaxServiceImpl(input, franceRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 200000, relationship: 'child' };
+        const service = new FranceInheritanceTaxServiceImpl(input, franceRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 200000) * 100);
+    });
+});

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

@@ -0,0 +1,100 @@
+import { GermanyInheritanceTaxServiceImpl } from '../src/inheritance-tax/germany/GermanyInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/germany/domain/types';
+
+const germanyRules: Rules = {
+    taxClasses: {
+        I: {
+            exemption: 500000,
+            brackets: [
+                { from: 0, to: 75000, rate: 0.07 },
+                { from: 75000, to: 300000, rate: 0.11 },
+                { from: 300000, to: 600000, rate: 0.15 },
+                { from: 600000, to: 6000000, rate: 0.19 },
+                { from: 6000000, to: 13000000, rate: 0.23 },
+                { from: 13000000, to: 26000000, rate: 0.27 },
+                { from: 26000000, to: null, rate: 0.30 },
+            ],
+        },
+        II: {
+            exemption: 20000,
+            brackets: [
+                { from: 0, to: 75000, rate: 0.15 },
+                { from: 75000, to: 300000, rate: 0.20 },
+                { from: 300000, to: 600000, rate: 0.25 },
+                { from: 600000, to: 6000000, rate: 0.30 },
+                { from: 6000000, to: 13000000, rate: 0.35 },
+                { from: 13000000, to: 26000000, rate: 0.40 },
+                { from: 26000000, to: null, rate: 0.43 },
+            ],
+        },
+        III: {
+            exemption: 20000,
+            brackets: [
+                { from: 0, to: 75000, rate: 0.30 },
+                { from: 75000, to: 300000, rate: 0.30 },
+                { from: 300000, to: 600000, rate: 0.30 },
+                { from: 600000, to: 6000000, rate: 0.30 },
+                { from: 6000000, to: 13000000, rate: 0.50 },
+                { from: 13000000, to: 26000000, rate: 0.50 },
+                { from: 26000000, to: null, rate: 0.50 },
+            ],
+        },
+    },
+};
+
+describe('GermanyInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for Class I estate below exemption', () => {
+        const input: Input = { estateValue: 400000, taxClass: 'I' };
+        const service = new GermanyInheritanceTaxServiceImpl(input, germanyRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates Class I tax for estate above exemption', () => {
+        const input: Input = { estateValue: 575000, taxClass: 'I' }; // 75000 above exemption
+        const service = new GermanyInheritanceTaxServiceImpl(input, germanyRules);
+        const result = service.calculate();
+
+        // 75000 * 0.07 = 5250
+        expect(result.taxableEstate).toBe(75000);
+        expect(result.inheritanceTax).toBeCloseTo(5250, 2);
+    });
+
+    it('correctly calculates Class II tax with lower exemption', () => {
+        const input: Input = { estateValue: 95000, taxClass: 'II' }; // 75000 above exemption
+        const service = new GermanyInheritanceTaxServiceImpl(input, germanyRules);
+        const result = service.calculate();
+
+        // 75000 * 0.15 = 11250
+        expect(result.taxableEstate).toBe(75000);
+        expect(result.inheritanceTax).toBe(11250);
+    });
+
+    it('correctly calculates Class III tax with higher rates', () => {
+        const input: Input = { estateValue: 95000, taxClass: 'III' }; // 75000 above exemption
+        const service = new GermanyInheritanceTaxServiceImpl(input, germanyRules);
+        const result = service.calculate();
+
+        // 75000 * 0.30 = 22500
+        expect(result.taxableEstate).toBe(75000);
+        expect(result.inheritanceTax).toBe(22500);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, taxClass: 'I' };
+        const service = new GermanyInheritanceTaxServiceImpl(input, germanyRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 1000000, taxClass: 'I' };
+        const service = new GermanyInheritanceTaxServiceImpl(input, germanyRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 1000000) * 100);
+    });
+});

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

@@ -0,0 +1,71 @@
+import { IndiaCapitalGainsServiceImpl } from '../src/capital-gains/india/IndiaCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/india/domain/types';
+
+const indiaRules: Rules = {
+    shortTermRate: 0.20,
+    longTermRate: 0.125,
+    longTermExemption: 125000,
+};
+
+describe('IndiaCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0, holdingPeriodMonths: 6 };
+        const service = new IndiaCapitalGainsServiceImpl(input, indiaRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(0);
+        expect(result.capitalGainTax).toBe(0);
+        expect(result.totalTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+    });
+
+    it('correctly calculates short-term capital gains tax', () => {
+        const input: Input = { capitalGain: 500000, holdingPeriodMonths: 6 };
+        const service = new IndiaCapitalGainsServiceImpl(input, indiaRules);
+        const result = service.calculate();
+
+        // Short-term: 500000 * 0.20 = 100000
+        expect(result.capitalGainTax).toBe(100000);
+        expect(result.totalTax).toBe(100000);
+        expect(result.effectiveRate).toBeCloseTo(20, 2);
+    });
+
+    it('returns zero tax for long-term gain fully within the exemption', () => {
+        const input: Input = { capitalGain: 100000, holdingPeriodMonths: 24 };
+        const service = new IndiaCapitalGainsServiceImpl(input, indiaRules);
+        const result = service.calculate();
+
+        // Long-term: max(0, 100000 - 125000) = 0 taxable
+        expect(result.capitalGainTax).toBe(0);
+        expect(result.totalTax).toBe(0);
+    });
+
+    it('correctly calculates long-term capital gains above the exemption', () => {
+        const input: Input = { capitalGain: 500000, holdingPeriodMonths: 24 };
+        const service = new IndiaCapitalGainsServiceImpl(input, indiaRules);
+        const result = service.calculate();
+
+        // Long-term: max(0, 500000 - 125000) = 375000 * 0.125 = 46875
+        expect(result.capitalGainTax).toBe(46875);
+        expect(result.totalTax).toBe(46875);
+    });
+
+    it('long-term rate is lower than short-term rate for the same gain', () => {
+        const longTermInput: Input = { capitalGain: 500000, holdingPeriodMonths: 24 };
+        const shortTermInput: Input = { capitalGain: 500000, holdingPeriodMonths: 6 };
+
+        const longTermTax = new IndiaCapitalGainsServiceImpl(longTermInput, indiaRules).calculate().capitalGainTax;
+        const shortTermTax = new IndiaCapitalGainsServiceImpl(shortTermInput, indiaRules).calculate().capitalGainTax;
+
+        expect(longTermTax).toBeLessThan(shortTermTax);
+    });
+
+    it('holding period of exactly 12 months is treated as long-term', () => {
+        const input: Input = { capitalGain: 500000, holdingPeriodMonths: 12 };
+        const service = new IndiaCapitalGainsServiceImpl(input, indiaRules);
+        const result = service.calculate();
+
+        // Long-term: max(0, 500000 - 125000) = 375000 * 0.125 = 46875
+        expect(result.capitalGainTax).toBe(46875);
+    });
+});

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

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