fix more tests

Author: nicosampler

src/test/utils/buildRemoveLiquidityCallData.test.ts

@@ -1,82 +1,177 @@
 import { V4PositionManager } from '@uniswap/v4-sdk'
+import { Percent } from '@uniswap/sdk-core'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { createMockSdkInstance } from '@/test/helpers/sdkInstance'
-import { createMockPositionData } from '@/test/helpers/testFactories'
+import { createMockPositionData, createTestPool } from '@/test/helpers/testFactories'
 import { getPosition } from '@/utils/getPosition'
+import { getDefaultDeadline } from '@/utils/getDefaultDeadline'
+import { percentFromBips } from '@/helpers/percent'
+import { DEFAULT_SLIPPAGE_TOLERANCE } from '@/constants/common'
+import type { GetPositionResponse } from '@/types/utils/getPosition'
+import { buildRemoveLiquidityCallData } from '@/utils/buildRemoveLiquidityCallData'
 
-const instance = createMockSdkInstance()
-const mockPosition = createMockPositionData()
+// Test constants
+const MOCK_DEADLINE = BigInt(1234567890)
+const MOCK_DEADLINE_STRING = '1234567890'
+const MOCK_SLIPPAGE_PERCENT = new Percent(50, 10000) // 0.5%
+const MOCK_CALLDATA = '0x1234567890abcdef'
+const MOCK_VALUE = '0x0'
+const CUSTOM_SLIPPAGE_BIPS = 500 // 5%
+const CUSTOM_DEADLINE = '1234567890'
+const CUSTOM_LIQUIDITY_PERCENTAGE = 7500 // 75%
+const MOCK_TOKEN_ID = '123'
 
+// Mock the V4PositionManager.removeCallParameters method
+vi.mock('@uniswap/v4-sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@uniswap/v4-sdk')>()
+  return {
+    ...actual,
+    V4PositionManager: {
+      ...actual.V4PositionManager,
+      removeCallParameters: vi.fn(),
+    },
+  }
+})
+
+// Mock getPosition
 vi.mock('@/utils/getPosition', () => ({
   getPosition: vi.fn(),
 }))
 
+// Mock getDefaultDeadline
 vi.mock('@/utils/getDefaultDeadline', () => ({
-  getDefaultDeadline: vi.fn().mockResolvedValue('1234567890'),
+  getDefaultDeadline: vi.fn(),
 }))
 
+// Mock percentFromBips
+vi.mock('@/helpers/percent', () => ({
+  percentFromBips: vi.fn(),
+}))
+
+// Type for the options passed to V4PositionManager.removeCallParameters
+type RemoveCallParametersOptions = {
+  slippageTolerance: unknown
+  deadline: string
+  liquidityPercentage: unknown
+  tokenId: string
+}
+
 describe('buildRemoveLiquidityCallData', () => {
+  const instance = createMockSdkInstance()
+  const pool = createTestPool()
+  const mockPositionData = createMockPositionData(pool)
+
+  // Get mocked functions at module level
+  const mockRemoveCallParameters = vi.mocked(V4PositionManager.removeCallParameters)
+  const mockGetPosition = vi.mocked(getPosition)
+  const mockGetDefaultDeadline = vi.mocked(getDefaultDeadline)
+  const mockPercentFromBips = vi.mocked(percentFromBips)
+
   beforeEach(() => {
-    vi.resetAllMocks()
-  })
+    vi.clearAllMocks()
 
-  it('should build calldata for removing liquidity', async () => {
-    vi.mocked(getPosition).mockResolvedValueOnce(mockPosition)
-    vi.spyOn(V4PositionManager, 'removeCallParameters').mockReturnValueOnce({
-      calldata: '0x123',
-      value: '0',
+    // Default mock implementations
+    mockRemoveCallParameters.mockReturnValue({
+      calldata: MOCK_CALLDATA,
+      value: MOCK_VALUE,
     })
 
-    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
-    const result = await buildRemoveLiquidityCallData(
-      { liquidityPercentage: 10_000, tokenId: '1', deadline: '123' },
-      instance,
-    )
-
-    expect(result.calldata).toBe('0x123')
-    expect(result.value).toBe('0')
+    mockGetPosition.mockResolvedValue(mockPositionData)
+    mockGetDefaultDeadline.mockResolvedValue(MOCK_DEADLINE)
+    mockPercentFromBips.mockReturnValue(MOCK_SLIPPAGE_PERCENT)
   })
 
-  it('should use custom slippageTolerance', async () => {
-    vi.mocked(getPosition).mockResolvedValueOnce(mockPosition)
-    const spy = vi.spyOn(V4PositionManager, 'removeCallParameters').mockReturnValueOnce({
-      calldata: '0xabc',
-      value: '1',
+  it('should call V4PositionManager.removeCallParameters with correct parameters when all required params are provided', async () => {
+    const params = {
+      liquidityPercentage: 10_000, // 100%
+      tokenId: MOCK_TOKEN_ID,
+      deadline: CUSTOM_DEADLINE,
+      slippageTolerance: CUSTOM_SLIPPAGE_BIPS,
+    }
+
+    const result = await buildRemoveLiquidityCallData(params, instance)
+
+    // Verify getPosition was called with correct tokenId
+    expect(mockGetPosition).toHaveBeenCalledWith({ tokenId: MOCK_TOKEN_ID }, instance)
+
+    // Verify getDefaultDeadline was NOT called since custom deadline was provided
+    expect(mockGetDefaultDeadline).not.toHaveBeenCalled()
+
+    // Verify percentFromBips was called with custom slippage
+    expect(mockPercentFromBips).toHaveBeenCalledWith(CUSTOM_SLIPPAGE_BIPS)
+    expect(mockPercentFromBips).toHaveBeenCalledWith(10_000) // liquidityPercentage
+
+    // Verify V4PositionManager.removeCallParameters was called with exact parameters
+    expect(mockRemoveCallParameters).toHaveBeenCalledTimes(1)
+    const [position, options] = mockRemoveCallParameters.mock.calls[0]
+
+    expect(position).toBe(mockPositionData.position)
+    expect(options).toEqual({
+      slippageTolerance: MOCK_SLIPPAGE_PERCENT,
+      deadline: CUSTOM_DEADLINE,
+      liquidityPercentage: MOCK_SLIPPAGE_PERCENT, // percentFromBips result for liquidityPercentage
+      tokenId: MOCK_TOKEN_ID,
     })
 
-    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
-    await buildRemoveLiquidityCallData(
-      { liquidityPercentage: 5000, tokenId: '1', slippageTolerance: 123, deadline: '123' },
-      instance,
+    // Verify return value
+    expect(result).toEqual({
+      calldata: MOCK_CALLDATA,
+      value: MOCK_VALUE,
+    })
+  })
+
+  it('should call V4PositionManager.removeCallParameters with default deadline when not provided', async () => {
+    const params = {
+      liquidityPercentage: CUSTOM_LIQUIDITY_PERCENTAGE,
+      tokenId: MOCK_TOKEN_ID,
+    }
+
+    await buildRemoveLiquidityCallData(params, instance)
+
+    // Verify getDefaultDeadline was called
+    expect(mockGetDefaultDeadline).toHaveBeenCalledWith(instance)
+
+    // Verify percentFromBips was called with default slippage
+    expect(mockPercentFromBips).toHaveBeenCalledWith(DEFAULT_SLIPPAGE_TOLERANCE)
+    expect(mockPercentFromBips).toHaveBeenCalledWith(CUSTOM_LIQUIDITY_PERCENTAGE)
+
+    expect(mockRemoveCallParameters).toHaveBeenCalledTimes(1)
+    const [, options] = mockRemoveCallParameters.mock.calls[0]
+
+    expect((options as RemoveCallParametersOptions).deadline).toBe(MOCK_DEADLINE_STRING)
+    expect((options as RemoveCallParametersOptions).slippageTolerance).toEqual(
+      MOCK_SLIPPAGE_PERCENT,
     )
+  })
 
-    expect(spy).toHaveBeenCalledWith(
-      mockPosition.position,
-      expect.objectContaining({ slippageTolerance: expect.any(Object) }),
+  it('should call V4PositionManager.removeCallParameters with default slippage when not provided', async () => {
+    const params = {
+      liquidityPercentage: 5000, // 50%
+      tokenId: MOCK_TOKEN_ID,
+      deadline: CUSTOM_DEADLINE,
+    }
+
+    await buildRemoveLiquidityCallData(params, instance)
+
+    // Verify percentFromBips was called with default slippage
+    expect(mockPercentFromBips).toHaveBeenCalledWith(DEFAULT_SLIPPAGE_TOLERANCE)
+    expect(mockPercentFromBips).toHaveBeenCalledWith(5000)
+
+    expect(mockRemoveCallParameters).toHaveBeenCalledTimes(1)
+    const [, options] = mockRemoveCallParameters.mock.calls[0]
+
+    expect((options as RemoveCallParametersOptions).slippageTolerance).toEqual(
+      MOCK_SLIPPAGE_PERCENT,
     )
   })
 
-  it('should throw if position not found', async () => {
-    vi.mocked(getPosition).mockResolvedValueOnce(undefined as any)
+  it('should throw error when position is not found', async () => {
+    mockGetPosition.mockResolvedValueOnce(undefined as unknown as GetPositionResponse)
 
-    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
     await expect(
       buildRemoveLiquidityCallData({ liquidityPercentage: 10_000, tokenId: '404' }, instance),
     ).rejects.toThrow('Position not found')
-  })
-
-  it('should throw if V4PositionManager throws', async () => {
-    vi.mocked(getPosition).mockResolvedValueOnce(mockPosition)
-    vi.spyOn(V4PositionManager, 'removeCallParameters').mockImplementationOnce(() => {
-      throw new Error('fail')
-    })
 
-    const { buildRemoveLiquidityCallData } = await import('@/utils/buildRemoveLiquidityCallData')
-    await expect(
-      buildRemoveLiquidityCallData(
-        { liquidityPercentage: 10_000, tokenId: '1', deadline: '123' },
-        instance,
-      ),
-    ).rejects.toThrow('fail')
+    expect(mockRemoveCallParameters).not.toHaveBeenCalled()
   })
 })