@novha/calc-engines 6.3.0 → 8.0.0

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

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

@@ -0,0 +1,78 @@
+import { SpainInheritanceTaxServiceImpl } from '../src/inheritance-tax/spain/SpainInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/spain/domain/types';
+
+const spainRules: Rules = {
+    exemption: 0,
+    taxBrackets: [
+        { from: 0, to: 7993.46, rate: 0.0765 },
+        { from: 7993.46, to: 31956.34, rate: 0.102 },
+        { from: 31956.34, to: 79881.68, rate: 0.153 },
+        { from: 79881.68, to: 239389.13, rate: 0.2125 },
+        { from: 239389.13, to: 398777.54, rate: 0.255 },
+        { from: 398777.54, to: 797555.08, rate: 0.2975 },
+        { from: 797555.08, to: null, rate: 0.34 },
+    ],
+};
+
+describe('SpainInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for zero estate', () => {
+        const input: Input = { estateValue: 0 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        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 at or below the exemption', () => {
+        const rulesWithExemption: Rules = { ...spainRules, exemption: 100000 };
+        const input: Input = { estateValue: 80000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, rulesWithExemption);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates tax for estate in first bracket', () => {
+        const input: Input = { estateValue: 5000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        // 0-5000: 5000 * 0.0765 = 382.5
+        expect(result.taxableEstate).toBe(5000);
+        expect(result.inheritanceTax).toBeCloseTo(382.5, 2);
+    });
+
+    it('correctly calculates tax for estate spanning multiple brackets', () => {
+        const input: Input = { estateValue: 100000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        // 0-7993.46: 7993.46 * 0.0765 ≈ 611.50
+        // 7993.46-31956.34: 23962.88 * 0.102 ≈ 2444.21
+        // 31956.34-79881.68: 47925.34 * 0.153 ≈ 7332.58
+        // 79881.68-100000: 20118.32 * 0.2125 ≈ 4275.14
+        // Total ≈ 14663.43
+        expect(result.taxableEstate).toBe(100000);
+        expect(result.inheritanceTax).toBeCloseTo(14663.43, 0);
+    });
+
+    it('effective rate equals inheritance tax divided by estate times 100', () => {
+        const input: Input = { estateValue: 100000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo((result.inheritanceTax / 100000) * 100, 2);
+    });
+
+    it('taxable estate is reduced by the exemption amount', () => {
+        const rulesWithExemption: Rules = { ...spainRules, exemption: 20000 };
+        const input: Input = { estateValue: 50000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, rulesWithExemption);
+        const result = service.calculate();
+
+        expect(result.taxableEstate).toBe(30000);
+    });
+});

package/test/spain-mortgage.test.ts

@@ -0,0 +1,70 @@
+import { SpainMortgageServiceImpl } from '../src/mortgage/spain/SpainMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/spain/domain/types';
+
+const spainRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.80, maxAmortizationYears: 30 },
+    interest: { compounding: 'MONTHLY' },
+    transferTax: { brackets: [{ above: 0, rate: 0.07 }] },
+};
+
+const input: MortgageInput = {
+    propertyPrice: 300000,
+    downPayment: 60000,
+    annualInterestRate: 3.5,
+    amortizationYears: 25,
+    isFirstTimeBuyer: false,
+};
+
+describe('SpainMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        // loanAmount = 300000 - 60000 = 240000
+        expect(result.loanAmount).toBe(240000);
+    });
+
+    it('correctly calculates transfer tax', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        // transferTax = (300000 - 0) * 0.07 = 21000
+        expect(result.transferTax).toBeCloseTo(21000, 2);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('total paid equals monthly payment multiplied by total payments', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        const expectedTotal = result.monthlyPayment * (input.amortizationYears * 12);
+        expect(result.totalPaid).toBeCloseTo(expectedTotal, 2);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        expect(result.amortizationSchedule).toHaveLength(25);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new SpainMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 300000 };
+
+        expect(() => service.calculate(badInput, spainRules)).toThrow();
+    });
+});

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

@@ -0,0 +1,72 @@
+import { UKInheritanceTaxServiceImpl } from '../src/inheritance-tax/uk/UKInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/uk/domain/types';
+
+const ukRules: Rules = {
+    nilRateBand: 325000,
+    standardRate: 0.40,
+    charityRate: 0.36,
+    charityThreshold: 10,
+};
+
+describe('UKInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for estate below nil-rate band', () => {
+        const input: Input = { estateValue: 200000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('returns zero tax for estate at nil-rate band', () => {
+        const input: Input = { estateValue: 325000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('applies 40% rate for estate above nil-rate band', () => {
+        const input: Input = { estateValue: 500000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        // (500000 - 325000) * 0.40 = 70000
+        expect(result.taxableEstate).toBe(175000);
+        expect(result.inheritanceTax).toBe(70000);
+    });
+
+    it('applies 36% charity rate when charitable giving >= 10%', () => {
+        const input: Input = { estateValue: 500000, charitableGivingPercent: 10 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        // (500000 - 325000) * 0.36 = 63000
+        expect(result.taxableEstate).toBe(175000);
+        expect(result.inheritanceTax).toBe(63000);
+    });
+
+    it('applies standard rate when charitable giving < 10%', () => {
+        const input: Input = { estateValue: 500000, charitableGivingPercent: 9 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(70000);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 1000000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 1000000) * 100);
+    });
+});

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

@@ -0,0 +1,90 @@
+import { USAInheritanceTaxServiceImpl } from '../src/inheritance-tax/usa/USAInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/usa/domain/types';
+
+const usaRules: Rules = {
+    exemption: 13610000,
+    taxBrackets: [
+        { from: 0, to: 10000, rate: 0.18 },
+        { from: 10000, to: 20000, rate: 0.20 },
+        { from: 20000, to: 40000, rate: 0.22 },
+        { from: 40000, to: 60000, rate: 0.24 },
+        { from: 60000, to: 80000, rate: 0.26 },
+        { from: 80000, to: 100000, rate: 0.28 },
+        { from: 100000, to: 150000, rate: 0.30 },
+        { from: 150000, to: 250000, rate: 0.32 },
+        { from: 250000, to: 500000, rate: 0.34 },
+        { from: 500000, to: 750000, rate: 0.36 },
+        { from: 750000, to: 1000000, rate: 0.38 },
+        { from: 1000000, to: null, rate: 0.40 },
+    ],
+};
+
+describe('USAInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for estate below exemption', () => {
+        const input: Input = { estateValue: 10000000 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('returns zero tax for estate at exactly the exemption', () => {
+        const input: Input = { estateValue: 13610000 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates tax for estate just above exemption', () => {
+        const input: Input = { estateValue: 13620000 }; // 10000 above exemption
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        // 10000 * 0.18 = 1800
+        expect(result.taxableEstate).toBe(10000);
+        expect(result.inheritanceTax).toBe(1800);
+    });
+
+    it('correctly calculates tax with multiple brackets', () => {
+        const input: Input = { estateValue: 13660000 }; // 50000 above exemption
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        // 10000 * 0.18 = 1800
+        // 10000 * 0.20 = 2000
+        // 20000 * 0.22 = 4400
+        // 10000 * 0.24 = 2400
+        // Total = 10600
+        expect(result.taxableEstate).toBe(50000);
+        expect(result.inheritanceTax).toBe(10600);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+    });
+
+    it('returns zero for negative estate', () => {
+        const input: Input = { estateValue: -100000 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 14610000 }; // 1,000,000 above exemption
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 14610000) * 100);
+    });
+});