vibetunnel/VibeTunnelTests/TunnelServerTests.swift

import Testing
import Foundation
import HTTPTypes
import Hummingbird
import HummingbirdCore
import NIOCore
@testable import VibeTunnel

@Suite("TunnelServer Tests")
struct TunnelServerTests {
    
    // MARK: - Session ID Capture Tests
    
    @Test("Create session captures UUID from tty-fwd stdout")
    func testCreateSessionCapturesSessionId() async throws {
        // This test validates that the server correctly captures the session ID
        // from tty-fwd's stdout instead of using its own generated name.
        // This is critical for the fix we implemented to prevent 404 errors
        // when sending input to sessions.
        
        // Note: This is a unit test that would require mocking TTYForwardManager
        // For now, we'll document the expected behavior
        
        // Expected behavior:
        // 1. Server calls tty-fwd with --session-name argument
        // 2. tty-fwd prints a UUID to stdout (e.g., "a37ea008c-41f6-412f-bbba-f28f091267ce")
        // 3. Server captures this UUID from the pipe
        // 4. Server returns this UUID in the response, NOT the session name
        
        // This ensures the session ID used by clients matches what tty-fwd expects
        #expect(true) // Placeholder - would need TTYForwardManager mock
    }
    
    @Test("Create session handles missing session ID from stdout")
    func testCreateSessionHandlesMissingSessionId() async throws {
        // Test that server properly handles the case where tty-fwd
        // doesn't print a session ID to stdout within the timeout period
        
        // Expected behavior:
        // 1. Server waits up to 3 seconds for session ID
        // 2. If no ID received, returns error response with appropriate message
        // 3. Client receives clear error about session creation failure
        
        #expect(true) // Placeholder - would need TTYForwardManager mock
    }
    
    // MARK: - API Endpoint Tests
    
    @Test("Session input endpoint validates session existence")
    func testSessionInputValidation() async throws {
        // This test validates the /api/sessions/:sessionId/input endpoint
        // which was returning 404 due to session ID mismatch
        
        // Expected behavior:
        // 1. Endpoint receives session ID in URL parameter
        // 2. Calls tty-fwd --list-sessions to verify session exists
        // 3. Returns 404 if session not found in tty-fwd's list
        // 4. Returns 400 if session exists but is not running
        // 5. Returns 410 if session process is dead
        // 6. Successfully sends input if session is valid and running
        
        #expect(true) // Placeholder - would need full server setup
    }
    
    // MARK: - Error Response Tests
    
    @Test("Error responses are properly formatted JSON")
    func testErrorResponseFormat() async throws {
        // Test that all error responses follow consistent JSON format
        let server = TunnelServer(port: 0) // Use port 0 for testing
        
        // Test various error response methods
        let errorCases = [
            ("Not found", HTTPResponse.Status.notFound),
            ("Bad request", HTTPResponse.Status.badRequest),
            ("Internal error", HTTPResponse.Status.internalServerError)
        ]
        
        for (message, status) in errorCases {
            // Note: errorResponse is private, so we can't test directly
            // In a real test, we'd make HTTP requests to trigger these errors
            #expect(status.code >= 400)
        }
    }
    
    // MARK: - Integration Test Scenarios
    
    @Test("Full session lifecycle with correct ID")
    func testSessionLifecycle() async throws {
        // This integration test validates the complete fix:
        // 1. Create session and get UUID from tty-fwd
        // 2. List sessions and verify the UUID appears
        // 3. Send input using the UUID
        // 4. Kill session using the UUID
        // 5. Cleanup session using the UUID
        
        // All operations should succeed without 404 errors
        // because we're using the correct session ID throughout
        
        #expect(true) // Placeholder - would need running server
    }
    
    @Test(.tags(.regression), "Session ID mismatch bug does not regress")
    func testSessionIdMismatchRegression() async throws {
        // Regression test for the bug where Swift server returned
        // its own session name instead of tty-fwd's UUID
        
        // This test ensures:
        // 1. Server NEVER returns a session ID like "session_timestamp_partialUUID"
        // 2. Server ALWAYS returns a proper UUID format
        // 3. The returned session ID can be used for subsequent operations
        
        #expect(true) // Placeholder - would need full setup
    }
}

// MARK: - Test Tags

extension Tag {
    @Tag static var regression: Self
    @Tag static var sessionManagement: Self
    @Tag static var apiEndpoints: Self
}

// MARK: - Test Helpers

private extension TunnelServerTests {
    // Helper to validate UUID format
    func isValidUUID(_ string: String) -> Bool {
        UUID(uuidString: string) != nil
    }
    
    // Helper to parse error response
    func parseErrorResponse(from data: Data) throws -> String? {
        struct ErrorResponse: Codable {
            let error: String
        }
        
        let response = try JSONDecoder().decode(ErrorResponse.self, from: data)
        return response.error
    }
}