@novha/calc-engines 3.0.0 → 5.0.0

package/src/index.ts

@@ -102,5 +102,103 @@ export {
     MortgageOutput as UKMortgageOutput,
 } from './mortgage/uk/domain/types';
 
+// USA
+export { USAIncomeTaxServiceImpl as USAIncomeTaxService } from './income-tax/usa/USAIncomeTaxServiceImpl';
+export {
+    ComputedIncomeTaxValues as USAComputedIncomeTaxValues,
+    IncomeTaxRules as USAIncomeTaxRules,
+} from './income-tax/usa/domain/types';
+
+export { USAMortgageServiceImpl as USAMortgageService } from './mortgage/usa/USAMortgageServiceImpl';
+export {
+    MortgageRules as USAMortgageRules,
+    MortgageInput as USAMortgageInput,
+    MortgageOutput as USAMortgageOutput,
+} from './mortgage/usa/domain/types';
+
+export { USACorporateTaxServiceImpl as USACorporateTaxService } from './corporate/usa/USACorporateTaxServiceImpl';
+export {
+    Input as USACorporateTaxInput,
+    Rules as USACorporateTaxRules,
+    Result as USACorporateTaxResult,
+} from './corporate/usa/domain/types';
+
+// Germany
+export { GermanyIncomeTaxServiceImpl as GermanyIncomeTaxService } from './income-tax/germany/GermanyIncomeTaxServiceImpl';
+export {
+    ComputedIncomeTaxValues as GermanyComputedIncomeTaxValues,
+    IncomeTaxRules as GermanyIncomeTaxRules,
+} from './income-tax/germany/domain/types';
+
+export { GermanyMortgageServiceImpl as GermanyMortgageService } from './mortgage/germany/GermanyMortgageServiceImpl';
+export {
+    MortgageRules as GermanyMortgageRules,
+    MortgageInput as GermanyMortgageInput,
+    MortgageOutput as GermanyMortgageOutput,
+} from './mortgage/germany/domain/types';
+
+export { GermanyCorporateTaxServiceImpl as GermanyCorporateTaxService } from './corporate/germany/GermanyCorporateTaxServiceImpl';
+export {
+    Input as GermanyCorporateTaxInput,
+    Rules as GermanyCorporateTaxRules,
+    Result as GermanyCorporateTaxResult,
+} from './corporate/germany/domain/types';
+
+// Capital Gains - Canada
+export { CanadaCapitalGainsServiceImpl as CanadaCapitalGainsService } from './capital-gains/canada/CanadaCapitalGainsServiceImpl';
+export {
+    Input as CanadaCapitalGainsInput,
+    Rules as CanadaCapitalGainsRules,
+    Result as CanadaCapitalGainsResult,
+} from './capital-gains/canada/domain/types';
+
+// Capital Gains - France
+export { FranceCapitalGainsServiceImpl as FranceCapitalGainsService } from './capital-gains/france/FranceCapitalGainsServiceImpl';
+export {
+    Input as FranceCapitalGainsInput,
+    Rules as FranceCapitalGainsRules,
+    Result as FranceCapitalGainsResult,
+} from './capital-gains/france/domain/types';
+
+// Capital Gains - South Africa
+export { SouthAfricaCapitalGainsServiceImpl as SouthAfricaCapitalGainsService } from './capital-gains/south-africa/SouthAfricaCapitalGainsServiceImpl';
+export {
+    Input as SouthAfricaCapitalGainsInput,
+    Rules as SouthAfricaCapitalGainsRules,
+    Result as SouthAfricaCapitalGainsResult,
+} from './capital-gains/south-africa/domain/types';
+
+// Capital Gains - Australia
+export { AustraliaCapitalGainsServiceImpl as AustraliaCapitalGainsService } from './capital-gains/australia/AustraliaCapitalGainsServiceImpl';
+export {
+    Input as AustraliaCapitalGainsInput,
+    Rules as AustraliaCapitalGainsRules,
+    Result as AustraliaCapitalGainsResult,
+} from './capital-gains/australia/domain/types';
+
+// Capital Gains - UK
+export { UKCapitalGainsServiceImpl as UKCapitalGainsService } from './capital-gains/uk/UKCapitalGainsServiceImpl';
+export {
+    Input as UKCapitalGainsInput,
+    Rules as UKCapitalGainsRules,
+    Result as UKCapitalGainsResult,
+} from './capital-gains/uk/domain/types';
+
+// Capital Gains - USA
+export { USACapitalGainsServiceImpl as USACapitalGainsService } from './capital-gains/usa/USACapitalGainsServiceImpl';
+export {
+    Input as USACapitalGainsInput,
+    Rules as USACapitalGainsRules,
+    Result as USACapitalGainsResult,
+} from './capital-gains/usa/domain/types';
+
+// Capital Gains - Germany
+export { GermanyCapitalGainsServiceImpl as GermanyCapitalGainsService } from './capital-gains/germany/GermanyCapitalGainsServiceImpl';
+export {
+    Input as GermanyCapitalGainsInput,
+    Rules as GermanyCapitalGainsRules,
+    Result as GermanyCapitalGainsResult,
+} from './capital-gains/germany/domain/types';
+
 export { IncomeTaxCalculatorSchema } from './income-tax/domain/types';
 export * from './income-tax/domain/types';

package/src/mortgage/germany/GermanyMortgageService.ts

@@ -0,0 +1,5 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export interface GermanyMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/src/mortgage/germany/GermanyMortgageServiceImpl.ts

@@ -0,0 +1,111 @@
+import { GermanyMortgageService } from "./GermanyMortgageService";
+import {
+    AmortizationScheduleItem,
+    MortgageInput,
+    MortgageOutput,
+    MortgageRules,
+} from "./domain/types";
+
+export class GermanyMortgageServiceImpl implements GermanyMortgageService {
+
+    public calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput {
+        const loanAmount = input.propertyPrice - input.downPayment;
+
+        if (loanAmount <= 0) {
+            throw new Error('Invalid loan amount: down payment must be less than property price');
+        }
+
+        const totalPayments = input.amortizationYears * 12;
+        const monthlyRate = (input.annualInterestRate / 100) / 12;
+
+        const monthlyPayment = this.calculatePayment(loanAmount, monthlyRate, totalPayments);
+        const totalPaid = monthlyPayment * totalPayments;
+        const totalInterestPaid = totalPaid - loanAmount;
+
+        const landTransferTax = input.propertyPrice * rules.landTransferTax.rate;
+        const notaryFees = input.propertyPrice * rules.notaryFeeRate;
+        const registrationFees = input.propertyPrice * rules.registrationFeeRate;
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            landTransferTax,
+            notaryFees,
+            registrationFees,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: notaryFees,
+                    label: 'NOTARY_FEES',
+                },
+                bankFees: {
+                    value: registrationFees,
+                    label: 'REGISTRATION_FEES',
+                },
+                monthlyInsuranceFees: {
+                    value: 0,
+                    label: 'MONTHLY_INSURANCE_FEES',
+                },
+            },
+        };
+    }
+
+    private calculateAmortizationSchedule(
+        principal: number,
+        monthlyRate: number,
+        monthlyPayment: number,
+        totalPayments: number,
+        amortizationYears: number,
+    ): AmortizationScheduleItem[] {
+        const schedule: AmortizationScheduleItem[] = [];
+        let balance = principal;
+
+        for (let year = 1; year <= amortizationYears; year++) {
+            let yearlyPrincipal = 0;
+            let yearlyInterest = 0;
+
+            const paymentsInYear = Math.min(12, totalPayments - (year - 1) * 12);
+
+            for (let payment = 1; payment <= paymentsInYear; payment++) {
+                const interestPayment = balance * monthlyRate;
+                const principalPayment = monthlyPayment - interestPayment;
+
+                yearlyInterest += interestPayment;
+                yearlyPrincipal += principalPayment;
+                balance -= principalPayment;
+            }
+
+            schedule.push({
+                year,
+                principal: yearlyPrincipal,
+                interest: yearlyInterest,
+                balance: Math.max(0, balance),
+            });
+
+            if (balance <= 0) break;
+        }
+
+        return schedule;
+    }
+
+    private calculatePayment(principal: number, rate: number, periods: number): number {
+        if (rate === 0) {
+            return principal / periods;
+        }
+
+        return principal *
+            (rate * Math.pow(1 + rate, periods)) /
+            (Math.pow(1 + rate, periods) - 1);
+    }
+}

package/src/mortgage/germany/domain/types.ts

@@ -0,0 +1,49 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    landTransferTax: LandTransferTaxRules;
+    notaryFeeRate: number;
+    registrationFeeRate: number;
+}
+
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+
+export interface LandTransferTaxRules {
+    rate: number;
+}
+
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+}
+
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    landTransferTax: number;
+    notaryFees: number;
+    registrationFees: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/mortgage/usa/USAMortgageService.ts

@@ -0,0 +1,5 @@
+import { MortgageInput, MortgageOutput, MortgageRules } from "./domain/types";
+
+export interface USAMortgageService {
+    calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput;
+}

package/src/mortgage/usa/USAMortgageServiceImpl.ts

@@ -0,0 +1,134 @@
+import { USAMortgageService } from "./USAMortgageService";
+import {
+    AmortizationScheduleItem,
+    MortgageInput,
+    MortgageOutput,
+    MortgageRules,
+    TransferTaxBracket,
+} from "./domain/types";
+
+export class USAMortgageServiceImpl implements USAMortgageService {
+
+    public calculate(input: MortgageInput, rules: MortgageRules): MortgageOutput {
+        const loanAmount = input.propertyPrice - input.downPayment;
+
+        if (loanAmount <= 0) {
+            throw new Error('Invalid loan amount: down payment must be less than property price');
+        }
+
+        const totalPayments = input.amortizationYears * 12;
+        const monthlyRate = (input.annualInterestRate / 100) / 12;
+
+        const monthlyPayment = this.calculatePayment(loanAmount, monthlyRate, totalPayments);
+        const totalPaid = monthlyPayment * totalPayments;
+        const totalInterestPaid = totalPaid - loanAmount;
+
+        const transferTax = this.calculateTransferTax(
+            input.propertyPrice,
+            rules.transferTax.brackets,
+        );
+
+        const amortizationSchedule = this.calculateAmortizationSchedule(
+            loanAmount,
+            monthlyRate,
+            monthlyPayment,
+            totalPayments,
+            input.amortizationYears,
+        );
+
+        return {
+            loanAmount,
+            totalMortgage: loanAmount,
+            monthlyPayment,
+            totalInterestPaid,
+            totalPaid,
+            transferTax,
+            amortizationSchedule,
+            otherFees: {
+                notaryFees: {
+                    value: transferTax,
+                    label: 'TRANSFER_TAX',
+                },
+                bankFees: {
+                    value: 0,
+                    label: 'BANK_FEES',
+                },
+                monthlyInsuranceFees: {
+                    value: 0,
+                    label: 'MONTHLY_INSURANCE_FEES',
+                },
+            },
+        };
+    }
+
+    private calculateTransferTax(
+        propertyPrice: number,
+        brackets: TransferTaxBracket[],
+    ): number {
+        let tax = 0;
+        let previousLimit = 0;
+
+        for (const bracket of brackets) {
+            if (bracket.upTo !== undefined && propertyPrice > previousLimit) {
+                const taxable = Math.min(propertyPrice, bracket.upTo) - previousLimit;
+                tax += taxable * bracket.rate;
+                previousLimit = bracket.upTo;
+            }
+
+            if (bracket.above !== undefined && propertyPrice > bracket.above) {
+                tax += (propertyPrice - bracket.above) * bracket.rate;
+                break;
+            }
+        }
+
+        return tax;
+    }
+
+    private calculateAmortizationSchedule(
+        principal: number,
+        monthlyRate: number,
+        monthlyPayment: number,
+        totalPayments: number,
+        amortizationYears: number,
+    ): AmortizationScheduleItem[] {
+        const schedule: AmortizationScheduleItem[] = [];
+        let balance = principal;
+
+        for (let year = 1; year <= amortizationYears; year++) {
+            let yearlyPrincipal = 0;
+            let yearlyInterest = 0;
+
+            const paymentsInYear = Math.min(12, totalPayments - (year - 1) * 12);
+
+            for (let payment = 1; payment <= paymentsInYear; payment++) {
+                const interestPayment = balance * monthlyRate;
+                const principalPayment = monthlyPayment - interestPayment;
+
+                yearlyInterest += interestPayment;
+                yearlyPrincipal += principalPayment;
+                balance -= principalPayment;
+            }
+
+            schedule.push({
+                year,
+                principal: yearlyPrincipal,
+                interest: yearlyInterest,
+                balance: Math.max(0, balance),
+            });
+
+            if (balance <= 0) break;
+        }
+
+        return schedule;
+    }
+
+    private calculatePayment(principal: number, rate: number, periods: number): number {
+        if (rate === 0) {
+            return principal / periods;
+        }
+
+        return principal *
+            (rate * Math.pow(1 + rate, periods)) /
+            (Math.pow(1 + rate, periods) - 1);
+    }
+}

package/src/mortgage/usa/domain/types.ts

@@ -0,0 +1,52 @@
+import { OtherFees } from "../../domain/types";
+
+export interface MortgageRules {
+    loanConstraints: LoanConstraints;
+    interest: InterestRules;
+    transferTax: TransferTaxRules;
+}
+
+export interface LoanConstraints {
+    maxLtvPercent: number;
+    maxAmortizationYears: number;
+}
+
+export interface InterestRules {
+    compounding: 'MONTHLY';
+}
+
+export interface TransferTaxBracket {
+    upTo?: number;
+    above?: number;
+    rate: number;
+}
+
+export interface TransferTaxRules {
+    brackets: TransferTaxBracket[];
+}
+
+export interface AmortizationScheduleItem {
+    year: number;
+    principal: number;
+    interest: number;
+    balance: number;
+}
+
+export interface MortgageInput {
+    propertyPrice: number;
+    downPayment: number;
+    annualInterestRate: number;
+    amortizationYears: number;
+    isFirstTimeBuyer: boolean;
+}
+
+export interface MortgageOutput {
+    loanAmount: number;
+    totalMortgage: number;
+    monthlyPayment: number;
+    totalInterestPaid: number;
+    totalPaid: number;
+    transferTax: number;
+    amortizationSchedule: AmortizationScheduleItem[];
+    otherFees: OtherFees;
+}

package/src/shared/domain/types.ts

@@ -3,6 +3,7 @@ export enum CalculatorType {
     MORTGAGE = 'MORTGAGE',
     LOAN = 'LOAN',
     CORPORATE_TAX = 'CORPORATE_TAX',
+    CAPITAL_GAINS = 'CAPITAL_GAINS',
 }
 
 export interface RuleMeta {

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

@@ -0,0 +1,80 @@
+import { AustraliaCapitalGainsServiceImpl } from '../src/capital-gains/australia/AustraliaCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/australia/domain/types';
+
+// Australia 2024-25 individual marginal tax rates + 50% CGT discount
+const australiaCapitalGainsRules: Rules = {
+    cgtDiscount: 0.50,
+    cgtDiscountMinMonths: 12,
+    taxBrackets: [
+        { from: 0, to: 18200, rate: 0.00 },
+        { from: 18200, to: 45000, rate: 0.16 },
+        { from: 45000, to: 135000, rate: 0.30 },
+        { from: 135000, to: 190000, rate: 0.37 },
+        { from: 190000, to: null, rate: 0.45 },
+    ],
+};
+
+describe('AustraliaCapitalGainsServiceImpl', () => {
+    it('applies 50% CGT discount for assets held >= 12 months', () => {
+        const input: Input = { capitalGain: 100000, totalTaxableIncome: 100000, holdingPeriodMonths: 24 };
+        const service = new AustraliaCapitalGainsServiceImpl(input, australiaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(50000);
+    });
+
+    it('no discount for assets held < 12 months', () => {
+        const input: Input = { capitalGain: 100000, totalTaxableIncome: 100000, holdingPeriodMonths: 6 };
+        const service = new AustraliaCapitalGainsServiceImpl(input, australiaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(100000);
+    });
+
+    it('taxes discounted gain at marginal rates', () => {
+        const input: Input = { capitalGain: 40000, totalTaxableIncome: 40000, holdingPeriodMonths: 18 };
+        const service = new AustraliaCapitalGainsServiceImpl(input, australiaCapitalGainsRules);
+        const result = service.calculate();
+
+        // Taxable gain = 20000, no other income
+        // 18200 at 0% = 0, 1800 at 16% = 288
+        expect(result.taxableGain).toBe(20000);
+        expect(result.capitalGainsTax).toBeCloseTo(288, 2);
+    });
+
+    it('returns zero for zero gain', () => {
+        const input: Input = { capitalGain: 0, totalTaxableIncome: 50000, holdingPeriodMonths: 24 };
+        const service = new AustraliaCapitalGainsServiceImpl(input, australiaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.capitalGainsTax).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('returns zero for negative gain', () => {
+        const input: Input = { capitalGain: -5000, totalTaxableIncome: 50000, holdingPeriodMonths: 24 };
+        const service = new AustraliaCapitalGainsServiceImpl(input, australiaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.capitalGainsTax).toBe(0);
+    });
+
+    it('stacks gain on top of other income', () => {
+        const input: Input = { capitalGain: 20000, totalTaxableIncome: 70000, holdingPeriodMonths: 24 };
+        const service = new AustraliaCapitalGainsServiceImpl(input, australiaCapitalGainsRules);
+        const result = service.calculate();
+
+        // Other income = 50000, taxable gain = 10000 (50% discount)
+        // Gain falls in 50000-60000 range, all at 30%
+        expect(result.taxableGain).toBe(10000);
+        expect(result.capitalGainsTax).toBe(10000 * 0.30);
+    });
+
+    it('calculates effective rate based on full gain', () => {
+        const input: Input = { capitalGain: 20000, totalTaxableIncome: 70000, holdingPeriodMonths: 24 };
+        const service = new AustraliaCapitalGainsServiceImpl(input, australiaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.capitalGainsTax / 20000) * 100);
+    });
+});

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

@@ -0,0 +1,71 @@
+import { CanadaCapitalGainsServiceImpl } from '../src/capital-gains/canada/CanadaCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/canada/domain/types';
+
+// Canada 2024 federal tax brackets with 50% inclusion rate
+const canadaCapitalGainsRules: 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('CanadaCapitalGainsServiceImpl', () => {
+    it('applies 50% inclusion rate', () => {
+        const input: Input = { capitalGain: 100000, totalTaxableIncome: 100000 };
+        const service = new CanadaCapitalGainsServiceImpl(input, canadaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.taxableGain).toBe(50000);
+    });
+
+    it('taxes included gain at marginal rate for low income', () => {
+        const input: Input = { capitalGain: 40000, totalTaxableIncome: 40000 };
+        const service = new CanadaCapitalGainsServiceImpl(input, canadaCapitalGainsRules);
+        const result = service.calculate();
+
+        // Taxable gain = 20000, all in first bracket (15%)
+        expect(result.taxableGain).toBe(20000);
+        expect(result.capitalGainsTax).toBe(20000 * 0.15);
+    });
+
+    it('returns zero for zero gain', () => {
+        const input: Input = { capitalGain: 0, totalTaxableIncome: 50000 };
+        const service = new CanadaCapitalGainsServiceImpl(input, canadaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.capitalGainsTax).toBe(0);
+        expect(result.taxableGain).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('returns zero for negative gain', () => {
+        const input: Input = { capitalGain: -10000, totalTaxableIncome: 50000 };
+        const service = new CanadaCapitalGainsServiceImpl(input, canadaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.capitalGainsTax).toBe(0);
+    });
+
+    it('calculates effective rate based on full gain', () => {
+        const input: Input = { capitalGain: 100000, totalTaxableIncome: 100000 };
+        const service = new CanadaCapitalGainsServiceImpl(input, canadaCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.capitalGainsTax / 100000) * 100);
+    });
+
+    it('stacks gain on top of other income', () => {
+        const input: Input = { capitalGain: 20000, totalTaxableIncome: 70000 };
+        const service = new CanadaCapitalGainsServiceImpl(input, canadaCapitalGainsRules);
+        const result = service.calculate();
+
+        // Other income = 50000, taxable gain = 10000
+        // 10000 falls in first bracket (50000-55867 = 5867 at 15%, rest at 20.5%)
+        expect(result.taxableGain).toBe(10000);
+        expect(result.capitalGainsTax).toBeGreaterThan(0);
+    });
+});

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

@@ -0,0 +1,66 @@
+import { FranceCapitalGainsServiceImpl } from '../src/capital-gains/france/FranceCapitalGainsServiceImpl';
+import { Input, Rules } from '../src/capital-gains/france/domain/types';
+
+// France PFU (Prélèvement Forfaitaire Unique) 2024
+const franceCapitalGainsRules: Rules = {
+    flatTaxRate: 0.128,
+    socialContributionsRate: 0.172,
+};
+
+describe('FranceCapitalGainsServiceImpl', () => {
+    it('applies flat tax rate and social contributions', () => {
+        const input: Input = { capitalGain: 100000 };
+        const service = new FranceCapitalGainsServiceImpl(input, franceCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.incomeTax).toBe(12800);
+        expect(result.socialContributions).toBe(17200);
+        expect(result.totalTax).toBe(30000);
+    });
+
+    it('effective rate is 30% (12.8% + 17.2%)', () => {
+        const input: Input = { capitalGain: 50000 };
+        const service = new FranceCapitalGainsServiceImpl(input, franceCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo(30, 1);
+    });
+
+    it('returns two breakdowns (income tax + social)', () => {
+        const input: Input = { capitalGain: 100000 };
+        const service = new FranceCapitalGainsServiceImpl(input, franceCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.breakdowns).toHaveLength(2);
+        expect(result.breakdowns[0].rate).toBe(0.128);
+        expect(result.breakdowns[1].rate).toBe(0.172);
+    });
+
+    it('returns zero for zero gain', () => {
+        const input: Input = { capitalGain: 0 };
+        const service = new FranceCapitalGainsServiceImpl(input, franceCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.totalTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('returns zero for negative gain', () => {
+        const input: Input = { capitalGain: -10000 };
+        const service = new FranceCapitalGainsServiceImpl(input, franceCapitalGainsRules);
+        const result = service.calculate();
+
+        expect(result.totalTax).toBe(0);
+    });
+
+    it('scales linearly with gain amount', () => {
+        const input1: Input = { capitalGain: 100000 };
+        const input2: Input = { capitalGain: 200000 };
+
+        const result1 = new FranceCapitalGainsServiceImpl(input1, franceCapitalGainsRules).calculate();
+        const result2 = new FranceCapitalGainsServiceImpl(input2, franceCapitalGainsRules).calculate();
+
+        expect(result2.totalTax).toBe(result1.totalTax * 2);
+    });
+});