cell/tests/http.ce

// http_test.js
var http = use('http');
var os = use('os');

var got = false
var count = 0
http.fetch("https://dictionary.ink/find?word=theological", {
  on_data: e => {
    log.console(e.length)
    count++
  },
  callback: e => {
    for (var i in e) log.console(i)
    log.console(e.data)
    got = true
  }
})

log.console(`got hit ${count} times`)

os.exit()

// Deep comparison function (unchanged from previous version)
function deepCompare(expected, actual, path = '') {
    if (expected === actual) return { passed: true, messages: [] };

    if (typeof expected === 'string' && typeof actual === 'string') {
        if (expected === actual) {
            return { passed: true, messages: [] };
        }
        return {
            passed: false,
            messages: [`String mismatch at ${path}: expected "${expected}", got "${actual}"`]
        };
    }

    if (typeof expected === 'object' && expected !== null && 
        typeof actual === 'object' && actual !== null) {
        const expKeys = Object.keys(expected).sort();
        const actKeys = Object.keys(actual).sort();
        if (JSON.stringify(expKeys) !== JSON.stringify(actKeys)) {
            return {
                passed: false,
                messages: [`Object keys mismatch at ${path}: expected ${expKeys}, got ${actKeys}`]
            };
        }
        let messages = [];
        for (let key of expKeys) {
            const result = deepCompare(expected[key], actual[key], `${path}.${key}`);
            if (!result.passed) messages.push(...result.messages);
        }
        return { passed: messages.length === 0, messages };
    }

    return {
        passed: false,
        messages: [`Value mismatch at ${path}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`]
    };
}

// Test cases (slightly modified to include state tracking)
var testCases = [
    {
        name: "Basic GET request",
        url: "https://api.github.com",
        expected: { contains: "GitHub" },
        validate: function(result) { return result.toLowerCase().includes("github"); },
        completed: false,
        result: null,
        error: null
    },
    {
        name: "JSON response",
        url: "https://api.github.com/users/octocat",
        expected: { login: "octocat" },
        validate: function(result) {
            let parsed = JSON.parse(result);
            return deepCompare({ login: "octocat" }, { login: parsed.login });
        },
        completed: false,
        result: null,
        error: null
    },
    {
        name: "Follow redirect",
        url: "http://github.com",
        expected: { contains: "gihtub" },
        validate: function(result) { return result.toLowerCase().includes("github"); },
        completed: false,
        result: null,
        error: null
    },
    {
        name: "Invalid URL",
        url: "http://nonexistent.domain.xyz",
        expectError: true,
        validate: function(result) { return true; },
        completed: false,
        result: null,
        error: null
    },
    {
        name: "Malformed URL",
        url: "not-a-url",
        expectError: true,
        validate: function(result) { return true; },
        completed: false,
        result: null,
        error: null
    },
    {
        name: "Large response",
        url: "https://www.gutenberg.org/files/1342/1342-0.txt",
        expected: { contains: "Pride and Prejudice" },
        validate: function(result) { return result.includes("Pride and Prejudice"); },
        completed: false,
        result: null,
        error: null
    }
];

// Test execution state
var results = [];
var testCount = 0;
var activeRequests = 0;
var timeout = 5000; // 5 seconds timeout per test

// Start tests
function startTests() {
    testCount = testCases.length;
    activeRequests = testCount;

    for (let i = 0; i < testCases.length; i++) {
        let test = testCases[i];
        let testName = `Test ${i + 1}: ${test.name}`;

        http.fetch(test.url, function(result) {
            test.completed = true;
            activeRequests--;
            
            if (result.error) {
                test.error = result.error;
            } else {
                test.result = result.data;
            }
        });
    }

    // Start polling loop
    pollTests();
}

// Poll and check test completion
function pollTests() {
  let startTime = os.now();
  while (true) {
    http.poll();

    let allCompleted = activeRequests === 0;
    let timedOut = (os.now() - startTime) >= timeout;
    if (allCompleted || timedOut) {
      processResults();
      break;
    }

    // Sleep a bit to avoid pegging the CPU (requires a C function or std.sleep)
    // TODO: Implement!
  }
}

// Process and report results
function processResults() {
    for (let i = 0; i < testCases.length; i++) {
        let test = testCases[i];
        let testName = `Test ${i + 1}: ${test.name}`;
        let passed = true;
        let messages = [];

        if (!test.completed) {
            passed = false;
            messages.push("Test timed out");
        } else if (test.error) {
            if (test.expectError) {
                // Expected error occurred
            } else {
                passed = false;
                messages.push(`Request failed: ${test.error}`);
            }
        } else if (test.expectError) {
            passed = false;
            messages.push("Expected request to fail but it succeeded");
        } else {
            const validation = test.validate(test.result);
            if (typeof validation === 'boolean') {
                if (!validation) {
                    passed = false;
                    messages.push(`Validation failed for ${test.url}`);
                    messages.push(`Expected to contain: ${JSON.stringify(test.expected)}`);
                    messages.push(`Got: ${test.result.substring(0, 100)}...`);
                }
            } else if (!validation.passed) {
                passed = false;
                messages.push(...validation.messages);
            }
        }

        results.push({ testName, passed, messages });

        if (!passed) {
            log.console(`\nDetailed Failure Report for ${testName}:`);
            log.console(`URL: ${test.url}`);
            log.console(messages.join("\n"));
            log.console("");
        }
    }

    // Summary
    log.console("\nTest Summary:");
    results.forEach(result => {
        log.console(`${result.testName} - ${result.passed ? "Passed" : "Failed"}`);
        if (!result.passed) {
            log.console(result.messages.join("\n"));
        }
    });

    let passedCount = results.filter(r => r.passed).length;
    log.console(`\nResult: ${passedCount}/${testCount} tests passed`);

    if (passedCount < testCount) {
        log.console("Overall: FAILED");
        os.exit(1);
    } else {
        log.console("Overall: PASSED");
        os.exit(0);
    }
}

// Run the tests
startTests();