xuanwu-cli 2.2.0 → 2.3.2

package/__tests__/integration/auth.integration.test.ts

@@ -0,0 +1,243 @@
+/**
+ * 认证集成测试
+ * 测试 CLI 授权登录流程
+ */
+
+import { APIClient } from '../../src/api/client'
+import { SessionManager } from '../../src/lib/session'
+import { Connection } from '../../src/config/types'
+
+const API_URL = process.env.TEST_API_URL || 'https://i.xuanwu.dev.aimstek.cn'
+const TEST_EMAIL = process.env.TEST_USER_EMAIL || ''
+const TEST_PASSWORD = process.env.TEST_USER_PASSWORD || ''
+
+describe('Authentication Integration Tests', () => {
+  let sessionManager: SessionManager
+
+  beforeEach(() => {
+    sessionManager = new SessionManager()
+  })
+
+  afterEach(async () => {
+    await sessionManager.clearSession()
+  })
+
+  describe('Device Authorization Flow', () => {
+    test('should generate device code successfully', async () => {
+      const response = await fetch(`${API_URL}/api/cli/auth/device-code`, {
+        method: 'POST'
+      })
+
+      expect(response.ok).toBeTruthy()
+
+      const data = await response.json() as { sessionId: string; loginUrl: string; code: string }
+      expect(data.sessionId).toBeDefined()
+      expect(data.loginUrl).toBeDefined()
+      expect(data.code).toBeDefined()
+      expect(data.loginUrl).toContain('session_id')
+    })
+
+    test('should poll device auth status', async () => {
+      const deviceAuthRes = await fetch(`${API_URL}/api/cli/auth/device-code`, {
+        method: 'POST'
+      })
+      
+      const { sessionId } = await deviceAuthRes.json() as { sessionId: string }
+
+      const pollRes = await fetch(`${API_URL}/api/cli/auth/poll?session_id=${sessionId}`)
+      expect(pollRes.ok).toBeTruthy()
+
+      const pollData = await pollRes.json() as { status: string }
+      expect(['pending', 'expired']).toContain(pollData.status)
+    }, 10000)
+  })
+
+  describe('Email/Password Login', () => {
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should login with credentials successfully', async () => {
+      const response = await fetch(`${API_URL}/api/cli/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          deviceName: 'Test CLI',
+          expiresIn: '30d'
+        })
+      })
+
+      expect(response.ok).toBeTruthy()
+
+      const data = await response.json() as { token: string; user: { id: string; name: string; email: string; role: string } }
+      expect(data.token).toBeDefined()
+      expect(data.user).toBeDefined()
+      expect(data.user.email).toBe(TEST_EMAIL)
+    })
+
+    test('should fail with invalid credentials', async () => {
+      const response = await fetch(`${API_URL}/api/cli/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          email: 'invalid@example.com',
+          password: 'wrongpassword',
+          deviceName: 'Test CLI'
+        })
+      })
+
+      expect(response.ok).toBeFalsy()
+      expect(response.status).toBe(401)
+    })
+  })
+
+  describe('Token Management', () => {
+    let testToken: string
+    let apiClient: APIClient
+
+    beforeAll(async () => {
+      if (TEST_EMAIL && TEST_PASSWORD) {
+        const response = await fetch(`${API_URL}/api/cli/auth/login`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            email: TEST_EMAIL,
+            password: TEST_PASSWORD,
+            deviceName: 'Test CLI',
+            expiresIn: '30d'
+          })
+        })
+        
+        if (response.ok) {
+          const data = await response.json() as { token: string; user: { id: string } }
+          testToken = data.token
+          
+          const conn: Connection = {
+            name: 'test',
+            endpoint: API_URL,
+            token: testToken,
+            isDefault: true
+          }
+          apiClient = new APIClient(conn)
+        }
+      }
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should verify token successfully', async () => {
+      const response = await fetch(`${API_URL}/api/cli/auth/verify`, {
+        headers: {
+          'Authorization': `Bearer ${testToken}`
+        }
+      })
+
+      expect(response.ok).toBeTruthy()
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should list tokens', async () => {
+      const response = await fetch(`${API_URL}/api/cli/auth/tokens`, {
+        headers: {
+          'Authorization': `Bearer ${testToken}`
+        }
+      })
+
+      expect(response.ok).toBeTruthy()
+      
+      const data = await response.json() as { tokens: any[] }
+      expect(Array.isArray(data.tokens)).toBeTruthy()
+    })
+  })
+
+  describe('Session Management', () => {
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should save and load session', async () => {
+      const response = await fetch(`${API_URL}/api/cli/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          deviceName: 'Test CLI',
+          expiresIn: '30d'
+        })
+      })
+
+      const data = await response.json() as { token: string; user: { id: string; name: string; email: string; role: string } }
+      
+      await sessionManager.saveSession({
+        token: data.token,
+        userId: data.user.id,
+        userName: data.user.name,
+        userEmail: data.user.email,
+        userRole: data.user.role,
+        deviceId: 'Test CLI',
+        expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+        apiUrl: API_URL
+      })
+
+      const session = await sessionManager.loadSession()
+      expect(session).toBeDefined()
+      expect(session?.token).toBe(data.token)
+      expect(session?.userEmail).toBe(TEST_EMAIL)
+    })
+
+    test('should clear session', async () => {
+      await sessionManager.saveSession({
+        token: 'test-token',
+        userId: 'test-user',
+        userName: 'Test User',
+        userEmail: 'test@example.com',
+        userRole: 'USER',
+        deviceId: 'Test Device',
+        expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+        apiUrl: API_URL
+      })
+
+      await sessionManager.clearSession()
+
+      const session = await sessionManager.loadSession()
+      expect(session).toBeNull()
+    })
+
+    test('should detect expired session', () => {
+      const expiredSession = {
+        token: 'test-token',
+        userId: 'test-user',
+        userName: 'Test User',
+        userEmail: 'test@example.com',
+        userRole: 'USER',
+        deviceId: 'Test Device',
+        expiresAt: new Date(Date.now() - 1000).toISOString(),
+        apiUrl: API_URL
+      }
+
+      expect(sessionManager.isExpired(expiredSession)).toBeTruthy()
+    })
+
+    test('should detect non-expired session', () => {
+      const validSession = {
+        token: 'test-token',
+        userId: 'test-user',
+        userName: 'Test User',
+        userEmail: 'test@example.com',
+        userRole: 'USER',
+        deviceId: 'Test Device',
+        expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+        apiUrl: API_URL
+      }
+
+      expect(sessionManager.isExpired(validSession)).toBeFalsy()
+    })
+
+    test('should handle session without expiration', () => {
+      const permanentSession = {
+        token: 'test-token',
+        userId: 'test-user',
+        userName: 'Test User',
+        userEmail: 'test@example.com',
+        userRole: 'USER',
+        deviceId: 'Test Device',
+        expiresAt: null,
+        apiUrl: API_URL
+      }
+
+      expect(sessionManager.isExpired(permanentSession)).toBeFalsy()
+    })
+  })
+})

package/__tests__/integration/build.integration.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Build 命令集成测试
+ * 测试 Build 相关的 CLI API
+ */
+
+import { APIClient } from '../../src/api/client'
+import { Connection } from '../../src/config/types'
+import { generateRandomCode } from '../helpers/test-utils'
+
+const API_URL = process.env.TEST_API_URL || 'https://i.xuanwu.dev.aimstek.cn'
+const TEST_EMAIL = process.env.TEST_USER_EMAIL || ''
+const TEST_PASSWORD = process.env.TEST_USER_PASSWORD || ''
+
+describe('Build Integration Tests', () => {
+  let apiClient: APIClient
+  let testToken: string
+  let testAppCode: string
+  let createdApps: string[] = []
+
+  beforeAll(async () => {
+    if (!TEST_EMAIL || !TEST_PASSWORD) {
+      console.warn('Skipping tests: TEST_USER_EMAIL and TEST_USER_PASSWORD not set')
+      return
+    }
+
+    const response = await fetch(`${API_URL}/api/cli/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        email: TEST_EMAIL,
+        password: TEST_PASSWORD,
+        deviceName: 'Test CLI',
+        expiresIn: '30d'
+      })
+    })
+
+    if (!response.ok) {
+      throw new Error('Failed to login')
+    }
+
+    const data = await response.json() as { token: string }
+    testToken = data.token
+
+    const conn: Connection = {
+      name: 'test',
+      endpoint: API_URL,
+      token: testToken,
+      isDefault: true
+    }
+    apiClient = new APIClient(conn)
+  })
+
+  afterAll(async () => {
+    for (const code of createdApps) {
+      try {
+        await apiClient.deleteApplication(code)
+      } catch (error) {
+        console.error(`Failed to cleanup app ${code}:`, error)
+      }
+    }
+  })
+
+  describe('List Builds', () => {
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should list all builds', async () => {
+      const result = await apiClient.listBuilds()
+
+      expect(result.success).toBeTruthy()
+      expect(Array.isArray(result.data)).toBeTruthy()
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should list builds with filter by app code', async () => {
+      testAppCode = generateRandomCode('build-test')
+      await apiClient.createApplication({
+        name: '构建测试应用',
+        code: testAppCode,
+        gitRepo: 'https://github.com/example/test.git'
+      })
+      createdApps.push(testAppCode)
+
+      await apiClient.triggerApplicationBuild(testAppCode)
+
+      const result = await apiClient.listBuilds({ appCode: testAppCode })
+
+      expect(result.success).toBeTruthy()
+      expect(Array.isArray(result.data)).toBeTruthy()
+      expect(result.data!.length).toBeGreaterThan(0)
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should list builds with filter by status', async () => {
+      const result = await apiClient.listBuilds({ status: 'SUCCESS' })
+
+      expect(result.success).toBeTruthy()
+      expect(Array.isArray(result.data)).toBeTruthy()
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should return empty array for non-existent app', async () => {
+      const result = await apiClient.listBuilds({ appCode: 'non-existent-app' })
+
+      expect(result.success).toBeTruthy()
+      expect(Array.isArray(result.data)).toBeTruthy()
+    })
+  })
+
+  describe('Get Build', () => {
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should get build by id', async () => {
+      testAppCode = generateRandomCode('build-test')
+      await apiClient.createApplication({
+        name: '构建测试应用',
+        code: testAppCode,
+        gitRepo: 'https://github.com/example/test.git'
+      })
+      createdApps.push(testAppCode)
+
+      const buildResult = await apiClient.triggerApplicationBuild(testAppCode)
+      const buildId = buildResult.data!.id
+
+      const result = await apiClient.getBuild(buildId)
+
+      expect(result.success).toBeTruthy()
+      expect(result.data).toBeDefined()
+      expect(result.data?.id).toBe(buildId)
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should return build with correct fields', async () => {
+      testAppCode = generateRandomCode('build-test')
+      await apiClient.createApplication({
+        name: '构建测试应用',
+        code: testAppCode,
+        gitRepo: 'https://github.com/example/test.git'
+      })
+      createdApps.push(testAppCode)
+
+      const buildResult = await apiClient.triggerApplicationBuild(testAppCode)
+      const buildId = buildResult.data!.id
+
+      const result = await apiClient.getBuild(buildId)
+
+      expect(result.success).toBeTruthy()
+      expect(result.data).toHaveProperty('id')
+      expect(result.data).toHaveProperty('buildNumber')
+      expect(result.data).toHaveProperty('status')
+      expect(result.data).toHaveProperty('createdAt')
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should fail to get non-existent build', async () => {
+      const result = await apiClient.getBuild('non-existent-build-id')
+
+      expect(result.success).toBeFalsy()
+      expect(result.error).toBeDefined()
+    })
+  })
+
+  describe('Cancel Build', () => {
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should cancel running build', async () => {
+      testAppCode = generateRandomCode('build-test')
+      await apiClient.createApplication({
+        name: '构建测试应用',
+        code: testAppCode,
+        gitRepo: 'https://github.com/example/test.git'
+      })
+      createdApps.push(testAppCode)
+
+      const buildResult = await apiClient.triggerApplicationBuild(testAppCode)
+      const buildId = buildResult.data!.id
+
+      const result = await apiClient.cancelBuild(buildId)
+
+      expect(result.success).toBeTruthy()
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should fail to cancel non-existent build', async () => {
+      const result = await apiClient.cancelBuild('non-existent-build-id')
+
+      expect(result.success).toBeFalsy()
+      expect(result.error).toBeDefined()
+    })
+
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should fail to cancel completed build', async () => {
+      const buildsResult = await apiClient.listBuilds({ status: 'SUCCESS' })
+      
+      if (!buildsResult.data || buildsResult.data.length === 0) {
+        console.warn('No completed builds found, skipping test')
+        return
+      }
+
+      const completedBuildId = buildsResult.data[0].id
+      const result = await apiClient.cancelBuild(completedBuildId)
+
+      expect(result.success).toBeFalsy()
+    })
+  })
+
+  describe('Build Lifecycle', () => {
+    test.skipIf(!TEST_EMAIL || !TEST_PASSWORD)('should track build status changes', async () => {
+      testAppCode = generateRandomCode('build-test')
+      await apiClient.createApplication({
+        name: '构建测试应用',
+        code: testAppCode,
+        gitRepo: 'https://github.com/example/test.git'
+      })
+      createdApps.push(testAppCode)
+
+      const buildResult = await apiClient.triggerApplicationBuild(testAppCode)
+      expect(buildResult.data?.status).toMatch(/PENDING|RUNNING/)
+
+      const buildId = buildResult.data!.id
+      
+      let build = await apiClient.getBuild(buildId)
+      expect(['PENDING', 'RUNNING', 'SUCCESS', 'FAILED']).toContain(build.data?.status)
+
+      const builds = await apiClient.listApplicationBuilds(testAppCode)
+      expect(builds.data?.some(b => b.id === buildId)).toBeTruthy()
+    })
+  })
+})