binance-api/tests/contract/platform-adapter-auth.contract.test.ts

/**
 * Contract test for IPlatformAdapter.prepareRequest()
 *
 * This test validates the platform adapter authentication functionality
 * according to the contract specification. Tests MUST FAIL until implementation is complete.
 */

import { describe, test, expect, beforeEach, jest } from '@jest/globals'

// Import types that will be implemented
import type { IPlatformAdapter, PlatformRequest, PreparedRequest } from '@/types/platformAdapter'

describe('IPlatformAdapter.prepareRequest() Contract', () => {
  let adapter: IPlatformAdapter

  beforeEach(() => {
    // This will fail until platform adapters are implemented
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    const { PacificaHttpAdapter } = require('@/adapters/pacifica/PacificaHttpAdapter')
    adapter = new PacificaHttpAdapter({
      platform: 'pacifica',
      baseUrl: 'https://api.pacifica.fi',
      authConfig: { type: 'signature', algorithm: 'Ed25519' }
    })
  })

  describe('Request Preparation', () => {
    test('should prepare authenticated request with signature', async () => {
      const request: PlatformRequest = {
        accountId: 'auth-account',
        method: 'POST',
        path: '/api/v1/orders',
        body: { symbol: 'BTC/USDT', side: 'buy', amount: '0.001' },
        options: { requiresAuth: true }
      }

      const prepared: PreparedRequest = await adapter.prepareRequest(request)

      expect(prepared).toBeDefined()
      expect(prepared.headers).toBeDefined()
      expect(prepared.headers['Authorization']).toBeDefined()
      expect(prepared.headers['X-Timestamp']).toBeDefined()
      expect(prepared.headers['X-Signature']).toBeDefined()
      expect(prepared.authenticated).toBe(true)
      expect(prepared.signatureAlgorithm).toBe('Ed25519')
    })

    test('should prepare public request without authentication', async () => {
      const request: PlatformRequest = {
        accountId: 'any-account',
        method: 'GET',
        path: '/api/v1/markets',
        options: { requiresAuth: false }
      }

      const prepared: PreparedRequest = await adapter.prepareRequest(request)

      expect(prepared).toBeDefined()
      expect(prepared.authenticated).toBe(false)
      expect(prepared.headers['Authorization']).toBeUndefined()
      expect(prepared.headers['X-Signature']).toBeUndefined()
    })

    test('should integrate with credential-manager for signing', async () => {
      const request: PlatformRequest = {
        accountId: 'credential-account',
        method: 'POST',
        path: '/api/v1/orders',
        body: { test: 'data' },
        options: { requiresAuth: true }
      }

      const prepared: PreparedRequest = await adapter.prepareRequest(request)

      expect(prepared).toBeDefined()
      expect(prepared.credentialManagerUsed).toBe(true)
      expect(prepared.signatureVerified).toBe(true)
    })
  })

  describe('Platform-Specific Authentication', () => {
    test('should handle Pacifica Ed25519 signature', async () => {
      const request: PlatformRequest = {
        accountId: 'pacifica-account',
        method: 'POST',
        path: '/api/v1/orders',
        body: { symbol: 'BTC/USDT' },
        options: { requiresAuth: true }
      }

      const prepared: PreparedRequest = await adapter.prepareRequest(request)

      expect(prepared.signatureAlgorithm).toBe('Ed25519')
      expect(prepared.headers['X-Signature']).toMatch(/^[a-fA-F0-9]{128}$/)
    })
  })

  describe('Error Handling', () => {
    test('should handle missing credentials gracefully', async () => {
      const request: PlatformRequest = {
        accountId: 'missing-credentials-account',
        method: 'POST',
        path: '/api/v1/orders',
        body: { test: 'data' },
        options: { requiresAuth: true }
      }

      await expect(adapter.prepareRequest(request)).rejects.toThrow(/credentials not found/i)
    })
  })
})