|
| 1 | +import { |
| 2 | + calculateTieredFeeBps, |
| 3 | + calculateFee, |
| 4 | + calculateNetAmount, |
| 5 | + getFeeTier, |
| 6 | + formatFeeDisplay, |
| 7 | + FEE_TIERS, |
| 8 | + BPS_DENOMINATOR, |
| 9 | +} from './fee.util'; |
| 10 | + |
| 11 | +describe('Fee Calculation Utilities', () => { |
| 12 | + describe('calculateTieredFeeBps', () => { |
| 13 | + it('should return 50 bps for amounts 0-1000', () => { |
| 14 | + expect(calculateTieredFeeBps(500)).toBe(50); |
| 15 | + expect(calculateTieredFeeBps(1000)).toBe(50); |
| 16 | + }); |
| 17 | + |
| 18 | + it('should return 30 bps for amounts 1001-5000', () => { |
| 19 | + expect(calculateTieredFeeBps(1001)).toBe(30); |
| 20 | + expect(calculateTieredFeeBps(5000)).toBe(30); |
| 21 | + }); |
| 22 | + |
| 23 | + it('should return 20 bps for amounts 5001-10000', () => { |
| 24 | + expect(calculateTieredFeeBps(5001)).toBe(20); |
| 25 | + expect(calculateTieredFeeBps(10000)).toBe(20); |
| 26 | + }); |
| 27 | + |
| 28 | + it('should return 10 bps for amounts 10001+', () => { |
| 29 | + expect(calculateTieredFeeBps(10001)).toBe(10); |
| 30 | + expect(calculateTieredFeeBps(100000)).toBe(10); |
| 31 | + }); |
| 32 | + |
| 33 | + it('should return default fee for zero or negative amounts', () => { |
| 34 | + expect(calculateTieredFeeBps(0)).toBe(50); |
| 35 | + expect(calculateTieredFeeBps(-1)).toBe(50); |
| 36 | + }); |
| 37 | + }); |
| 38 | + |
| 39 | + describe('calculateFee', () => { |
| 40 | + it('should calculate fee correctly for tier 1 (50 bps)', () => { |
| 41 | + // 1000 * 50 / 10000 = 5 |
| 42 | + expect(calculateFee(1000)).toBe(5); |
| 43 | + expect(calculateFee(10000)).toBe(50); // 10000 * 50 / 10000 = 50 |
| 44 | + }); |
| 45 | + |
| 46 | + it('should calculate fee correctly for tier 2 (30 bps)', () => { |
| 47 | + // 5000 * 30 / 10000 = 15 |
| 48 | + expect(calculateFee(5000)).toBe(15); |
| 49 | + }); |
| 50 | + |
| 51 | + it('should calculate fee correctly for tier 3 (20 bps)', () => { |
| 52 | + // 10000 * 20 / 10000 = 20 |
| 53 | + expect(calculateFee(10000)).toBe(20); |
| 54 | + }); |
| 55 | + |
| 56 | + it('should calculate fee correctly for tier 4 (10 bps)', () => { |
| 57 | + // 100000 * 10 / 10000 = 100 |
| 58 | + expect(calculateFee(100000)).toBe(100); |
| 59 | + }); |
| 60 | + |
| 61 | + it('should floor results to avoid fractional amounts', () => { |
| 62 | + // 333 * 50 / 10000 = 1.665 => 1 |
| 63 | + expect(calculateFee(333)).toBe(1); |
| 64 | + }); |
| 65 | + }); |
| 66 | + |
| 67 | + describe('calculateNetAmount', () => { |
| 68 | + it('should return fee and net amount correctly', () => { |
| 69 | + const result = calculateNetAmount(1000); |
| 70 | + expect(result.fee).toBe(5); // 1000 * 50 / 10000 |
| 71 | + expect(result.netAmount).toBe(995); // 1000 - 5 |
| 72 | + expect(result.feeBps).toBe(50); |
| 73 | + }); |
| 74 | + |
| 75 | + it('should handle tier transitions correctly', () => { |
| 76 | + const tier1Result = calculateNetAmount(1000); |
| 77 | + const tier2Result = calculateNetAmount(1001); |
| 78 | + |
| 79 | + expect(tier1Result.feeBps).toBe(50); |
| 80 | + expect(tier2Result.feeBps).toBe(30); // Lower fee for higher volume |
| 81 | + expect(tier2Result.fee).toBeLessThan(tier1Result.fee); |
| 82 | + }); |
| 83 | + |
| 84 | + it('should ensure net amount never exceeds total amount', () => { |
| 85 | + const result = calculateNetAmount(10000); |
| 86 | + expect(result.netAmount).toBeLessThanOrEqual(10000); |
| 87 | + expect(result.netAmount).toBeGreaterThanOrEqual(0); |
| 88 | + }); |
| 89 | + }); |
| 90 | + |
| 91 | + describe('getFeeTier', () => { |
| 92 | + it('should return correct tier info for tier 1', () => { |
| 93 | + const tier = getFeeTier(500); |
| 94 | + expect(tier.bps).toBe(50); |
| 95 | + expect(tier.range).toContain('1,000'); |
| 96 | + }); |
| 97 | + |
| 98 | + it('should return correct tier info for tier 2', () => { |
| 99 | + const tier = getFeeTier(2000); |
| 100 | + expect(tier.bps).toBe(30); |
| 101 | + expect(tier.range).toContain('1,001'); |
| 102 | + expect(tier.range).toContain('5,000'); |
| 103 | + }); |
| 104 | + |
| 105 | + it('should return correct tier info for tier 4 (max)', () => { |
| 106 | + const tier = getFeeTier(20000); |
| 107 | + expect(tier.bps).toBe(10); |
| 108 | + expect(tier.range).toContain('10,001+'); |
| 109 | + }); |
| 110 | + }); |
| 111 | + |
| 112 | + describe('formatFeeDisplay', () => { |
| 113 | + it('should format amounts correctly with XLM decimals', () => { |
| 114 | + const display = formatFeeDisplay(1_000_000_000, 7, 'XLM'); |
| 115 | + expect(display.amount).toBe('100 XLM'); |
| 116 | + expect(display.fee).toBe('0.5 XLM'); // 100 * 50 / 10000 |
| 117 | + expect(display.net).toBe('99.5 XLM'); |
| 118 | + expect(display.percentage).toBe('0.50%'); |
| 119 | + }); |
| 120 | + |
| 121 | + it('should format correctly for different decimals', () => { |
| 122 | + // 1000 stroops with 7 decimals = 0.0001 XLM |
| 123 | + const display = formatFeeDisplay(1000, 7, 'XLM'); |
| 124 | + expect(display.amount).toContain('0.00'); |
| 125 | + expect(display.percentage).toBe('0.50%'); |
| 126 | + }); |
| 127 | + }); |
| 128 | + |
| 129 | + describe('Edge cases', () => { |
| 130 | + it('should handle very large amounts', () => { |
| 131 | + const largeAmount = Number.MAX_SAFE_INTEGER - 1; |
| 132 | + const result = calculateNetAmount(largeAmount); |
| 133 | + expect(result.netAmount).toBeGreaterThan(0); |
| 134 | + expect(result.fee).toBeGreaterThan(0); |
| 135 | + expect(result.feeBps).toBe(10); // Highest tier |
| 136 | + }); |
| 137 | + |
| 138 | + it('should handle minimal amounts', () => { |
| 139 | + const result = calculateNetAmount(1); |
| 140 | + expect(result.fee).toBe(0); // 1 * 50 / 10000 = 0.0005 => 0 (floored) |
| 141 | + expect(result.netAmount).toBe(1); |
| 142 | + }); |
| 143 | + |
| 144 | + it('should ensure fee never exceeds amount', () => { |
| 145 | + for (let amount = 1; amount <= 100000; amount *= 10) { |
| 146 | + const result = calculateNetAmount(amount); |
| 147 | + expect(result.fee).toBeLessThanOrEqual(amount); |
| 148 | + expect(result.netAmount).toBeGreaterThanOrEqual(0); |
| 149 | + } |
| 150 | + }); |
| 151 | + }); |
| 152 | + |
| 153 | + describe('Tier boundaries', () => { |
| 154 | + it('should handle exact tier boundaries correctly', () => { |
| 155 | + expect(calculateTieredFeeBps(1000)).toBe(50); // At boundary |
| 156 | + expect(calculateTieredFeeBps(1001)).toBe(30); // Just over |
| 157 | + |
| 158 | + expect(calculateTieredFeeBps(5000)).toBe(30); // At boundary |
| 159 | + expect(calculateTieredFeeBps(5001)).toBe(20); // Just over |
| 160 | + |
| 161 | + expect(calculateTieredFeeBps(10000)).toBe(20); // At boundary |
| 162 | + expect(calculateTieredFeeBps(10001)).toBe(10); // Just over |
| 163 | + }); |
| 164 | + }); |
| 165 | +}); |
0 commit comments