@novha/calc-engines 7.0.0 → 7.0.1

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

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/israel-capital-gains.test.ts

@@ -0,0 +1,45 @@
+import { IsraelCapitalGainsServiceImpl } from '../src/capital-gains/israel/IsraelCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/israel/domain/types';
+
+const israelRules: Rules = {
+    brackets: [
+        { from: 0, to: null, rate: 0.25 },
+    ],
+};
+
+describe('IsraelCapitalGainsServiceImpl', () => {
+    it('returns zero tax for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        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 flat 25% tax', () => {
+        const input: Input = { capitalGain: 100000 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        const result = service.calculate();
+        // 100000 * 0.25 = 25000
+        expect(result.capitalGainTax).toBe(25000);
+        expect(result.totalTax).toBe(25000);
+        expect(result.effectiveRate).toBe(25);
+    });
+
+    it('taxable gain equals input capital gain', () => {
+        const input: Input = { capitalGain: 50000 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.taxableGain).toBe(50000);
+    });
+
+    it('effective rate equals total tax divided by gain times 100', () => {
+        const input: Input = { capitalGain: 200000 };
+        const service = new IsraelCapitalGainsServiceImpl(input, israelRules);
+        const result = service.calculate();
+        expect(result.effectiveRate).toBeCloseTo((result.capitalGainTax / 200000) * 100, 2);
+    });
+});

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

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

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

@@ -0,0 +1,76 @@
+import { IsraelIncomeTaxServiceImpl } from '../src/income-tax/israel/IsraelIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/israel/domain/types';
+
+const israelRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 81480, rate: 0.10 },
+        { from: 81480, to: 116760, rate: 0.14 },
+        { from: 116760, to: 187440, rate: 0.20 },
+        { from: 187440, to: 260520, rate: 0.31 },
+        { from: 260520, to: 542160, rate: 0.35 },
+        { from: 542160, to: null, rate: 0.47 },
+    ],
+    socialContributions: { rate: 0.12 },
+};
+
+describe('IsraelIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new IsraelIncomeTaxServiceImpl(0, israelRules);
+        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 IsraelIncomeTaxServiceImpl(50000, israelRules);
+        const result = service.calculateNetIncome();
+        // 50000 * 0.10 = 5000
+        expect(result.incomeTax).toBeCloseTo(5000, 2);
+        expect(result.grossIncome).toBe(50000);
+    });
+
+    it('correctly calculates social contributions', () => {
+        const service = new IsraelIncomeTaxServiceImpl(50000, israelRules);
+        const result = service.calculateNetIncome();
+        // 50000 * 0.12 = 6000
+        expect(result.socialContributions).toBeCloseTo(6000, 2);
+    });
+
+    it('correctly calculates income tax spanning multiple brackets', () => {
+        const service = new IsraelIncomeTaxServiceImpl(120000, israelRules);
+        const result = service.calculateNetIncome();
+        // 0-81480: 81480 * 0.10 = 8148
+        // 81480-116760: 35280 * 0.14 = 4939.2
+        // 116760-120000: 3240 * 0.20 = 648
+        // Total = 13735.2
+        expect(result.incomeTax).toBeCloseTo(13735.2, 1);
+    });
+
+    it('calculates effective tax rate as income tax divided by gross income', () => {
+        const service = new IsraelIncomeTaxServiceImpl(120000, israelRules);
+        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 IsraelIncomeTaxServiceImpl(120000, israelRules);
+        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 IsraelIncomeTaxServiceImpl(120000, israelRules);
+        const result = service.calculateNetIncome();
+        expect(result.totalDeductions).toBeCloseTo(result.incomeTax + result.socialContributions, 2);
+    });
+
+    it('applies highest bracket rate to income above 542160', () => {
+        const service = new IsraelIncomeTaxServiceImpl(600000, israelRules);
+        const result = service.calculateNetIncome();
+        expect(result.incomeTax).toBeGreaterThan(0);
+        const lastBreakdown = result.taxBracketBreakdown[result.taxBracketBreakdown.length - 1];
+        expect(lastBreakdown.rate).toBe(0.47);
+    });
+});