HarborForge.Frontend.Test/tests/real-plugin.spec.ts

/**
 * Real Plugin Integration Test
 * 
 * This test verifies the real OpenClaw plugin (installed on vps.t1) 
 * can successfully connect to and report telemetry to HarborForge Backend.
 * 
 * Prerequisites:
 * - vps.t1 must have HarborForge.OpenclawPlugin installed
 * - vps.t1's OpenClaw Gateway must be running with plugin enabled
 * - Backend must be accessible from vps.t1
 * 
 * Run with: ./run-test-frontend.sh --expose-port on --test-real-plugin
 */

import { test, expect } from '@playwright/test';

// Configuration from environment
const BACKEND_URL = process.env.BACKEND_URL || 'http://backend:8000';
const PLUGIN_SERVER_URL = process.env.PLUGIN_SERVER_URL || 'https://vps.t1:8000';
const TEST_TIMEOUT = 120000; // 2 minutes for real plugin communication

test.describe('Real OpenClaw Plugin Integration', () => {
  test.setTimeout(TEST_TIMEOUT);

  test.beforeAll(async () => {
    console.log('🔌 Testing real plugin integration...');
    console.log(`   Backend: ${BACKEND_URL}`);
    console.log(`   Plugin Server: ${PLUGIN_SERVER_URL}`);
  });

  /**
   * Test 1: Verify plugin can register server and get API key
   */
  test('should register server and generate API key', async ({ request }) => {
    // Login as admin to get session
    const loginRes = await request.post(`${BACKEND_URL}/auth/login`, {
      data: {
        username: 'admin',
        password: 'admin123', // Default test password
      },
    });
    
    expect(loginRes.ok()).toBeTruthy();
    const loginData = await loginRes.json();
    const token = loginData.access_token;
    
    // Register a new server for testing
    const serverRes = await request.post(`${BACKEND_URL}/monitor/admin/servers`, {
      headers: { 'Authorization': `Bearer ${token}` },
      data: {
        identifier: 'test-real-plugin-vps-t1',
        display_name: 'Test Real Plugin on vps.t1',
      },
    });
    
    expect(serverRes.ok()).toBeTruthy();
    const serverData = await serverRes.json();
    const serverId = serverData.id;
    
    console.log(`✅ Server registered: ID=${serverId}`);
    
    // Generate API key for this server
    const apiKeyRes = await request.post(`${BACKEND_URL}/monitor/admin/servers/${serverId}/api-key`, {
      headers: { 'Authorization': `Bearer ${token}` },
    });
    
    expect(apiKeyRes.ok()).toBeTruthy();
    const apiKeyData = await apiKeyRes.json();
    
    expect(apiKeyData.api_key).toBeDefined();
    expect(apiKeyData.api_key.length).toBeGreaterThan(30);
    
    console.log(`✅ API Key generated: ${apiKeyData.api_key.substring(0, 10)}...`);
    
    // Store for subsequent tests
    process.env.TEST_SERVER_ID = String(serverId);
    process.env.TEST_API_KEY = apiKeyData.api_key;
  });

  /**
   * Test 2: Verify plugin can send heartbeat with valid API key
   */
  test('should receive heartbeat from real plugin', async ({ request }) => {
    const apiKey = process.env.TEST_API_KEY;
    const serverId = process.env.TEST_SERVER_ID;
    
    expect(apiKey).toBeDefined();
    expect(serverId).toBeDefined();
    
    // Simulate a heartbeat from the plugin (as if vps.t1 sent it)
    const heartbeatRes = await request.post(`${BACKEND_URL}/monitor/server/heartbeat-v2`, {
      headers: { 'X-API-Key': apiKey },
      data: {
        identifier: 'test-real-plugin-vps-t1',
        openclaw_version: '0.1.0-test',
        agents: [
          { id: 'agent-1', name: 'TestAgent', status: 'active' }
        ],
        cpu_pct: 45.5,
        mem_pct: 60.2,
        disk_pct: 70.1,
        swap_pct: 10.0,
        load_avg: [1.2, 0.8, 0.5],
        uptime_seconds: 3600,
      },
    });
    
    expect(heartbeatRes.ok()).toBeTruthy();
    const heartbeatData = await heartbeatRes.json();
    
    expect(heartbeatData.ok).toBe(true);
    expect(heartbeatData.server_id).toBe(parseInt(serverId));
    expect(heartbeatData.identifier).toBe('test-real-plugin-vps-t1');
    expect(heartbeatData.last_seen_at).toBeDefined();
    
    console.log('✅ Heartbeat accepted by backend');
    console.log(`   Server ID: ${heartbeatData.server_id}`);
    console.log(`   Last seen: ${heartbeatData.last_seen_at}`);
  });

  /**
   * Test 3: Verify heartbeat data is stored in database
   */
  test('should persist telemetry data to database', async ({ request }) => {
    const apiKey = process.env.TEST_API_KEY;
    const serverId = process.env.TEST_SERVER_ID;
    
    // Wait a moment for data to be persisted
    await new Promise(resolve => setTimeout(resolve, 1000));
    
    // Login as admin
    const loginRes = await request.post(`${BACKEND_URL}/auth/login`, {
      data: { username: 'admin', password: 'admin123' },
    });
    
    expect(loginRes.ok()).toBeTruthy();
    const loginData = await loginRes.json();
    const token = loginData.access_token;
    
    // Query server state
    const stateRes = await request.get(`${BACKEND_URL}/monitor/admin/servers`, {
      headers: { 'Authorization': `Bearer ${token}` },
    });
    
    expect(stateRes.ok()).toBeTruthy();
    const servers = await stateRes.json();
    
    const testServer = servers.find((s: any) => s.id === parseInt(serverId));
    expect(testServer).toBeDefined();
    
    // Verify telemetry fields are stored
    expect(testServer.openclaw_version).toBe('0.1.0-test');
    expect(testServer.cpu_pct).toBeCloseTo(45.5, 1);
    expect(testServer.mem_pct).toBeCloseTo(60.2, 1);
    expect(testServer.last_seen_at).toBeDefined();
    
    console.log('✅ Telemetry data persisted:');
    console.log(`   Version: ${testServer.openclaw_version}`);
    console.log(`   CPU: ${testServer.cpu_pct}%`);
    console.log(`   Memory: ${testServer.mem_pct}%`);
  });

  /**
   * Test 4: Verify invalid API key is rejected
   */
  test('should reject heartbeat with invalid API key', async ({ request }) => {
    const heartbeatRes = await request.post(`${BACKEND_URL}/monitor/server/heartbeat-v2`, {
      headers: { 'X-API-Key': 'invalid-api-key-12345' },
      data: {
        identifier: 'test-real-plugin-vps-t1',
        openclaw_version: '0.1.0-test',
      },
    });
    
    expect(heartbeatRes.status()).toBe(401);
    const errorData = await heartbeatRes.json();
    
    expect(errorData.detail).toContain('Invalid');
    
    console.log('✅ Invalid API key correctly rejected (401)');
  });

  /**
   * Test 5: Verify missing API key is rejected
   */
  test('should reject heartbeat without API key', async ({ request }) => {
    const heartbeatRes = await request.post(`${BACKEND_URL}/monitor/server/heartbeat-v2`, {
      data: {
        identifier: 'test-real-plugin-vps-t1',
        openclaw_version: '0.1.0-test',
      },
    });
    
    expect(heartbeatRes.status()).toBe(422); // FastAPI validation error
    
    console.log('✅ Missing API key correctly rejected (422)');
  });

  /**
   * Test 6: Test API key revocation
   */
  test('should revoke API key and reject subsequent heartbeats', async ({ request }) => {
    const apiKey = process.env.TEST_API_KEY;
    const serverId = process.env.TEST_SERVER_ID;
    
    // Login as admin
    const loginRes = await request.post(`${BACKEND_URL}/auth/login`, {
      data: { username: 'admin', password: 'admin123' },
    });
    
    expect(loginRes.ok()).toBeTruthy();
    const loginData = await loginRes.json();
    const token = loginData.access_token;
    
    // Revoke API key
    const revokeRes = await request.delete(`${BACKEND_URL}/monitor/admin/servers/${serverId}/api-key`, {
      headers: { 'Authorization': `Bearer ${token}` },
    });
    
    expect(revokeRes.status()).toBe(204);
    
    console.log('✅ API key revoked');
    
    // Try to use revoked key
    const heartbeatRes = await request.post(`${BACKEND_URL}/monitor/server/heartbeat-v2`, {
      headers: { 'X-API-Key': apiKey },
      data: {
        identifier: 'test-real-plugin-vps-t1',
        openclaw_version: '0.1.0-test',
      },
    });
    
    expect(heartbeatRes.status()).toBe(401);
    
    console.log('✅ Revoked API key correctly rejected');
  });

  /**
   * Cleanup: Delete test server
   */
  test.afterAll(async ({ request }) => {
    const serverId = process.env.TEST_SERVER_ID;
    if (!serverId) return;
    
    try {
      const loginRes = await request.post(`${BACKEND_URL}/auth/login`, {
        data: { username: 'admin', password: 'admin123' },
      });
      
      if (!loginRes.ok()) return;
      
      const loginData = await loginRes.json();
      const token = loginData.access_token;
      
      // Delete test server
      const deleteRes = await request.delete(`${BACKEND_URL}/monitor/admin/servers/${serverId}`, {
        headers: { 'Authorization': `Bearer ${token}` },
      });
      
      if (deleteRes.status() === 204) {
        console.log(`✅ Test server ${serverId} cleaned up`);
      }
    } catch (e) {
      console.log(`⚠️ Cleanup warning: ${e}`);
    }
  });
});