ruchy 4.1.1

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! TDD test for notebook API
//! This will FAIL until we fix the route registration

use std::time::Duration;
use tokio::time::timeout;

#[tokio::test]
async fn test_api_execute_returns_200_not_404() {
    // Start a real server and test it

    // This should FAIL with curl returning 404
    let result = timeout(Duration::from_secs(5), test_real_api_call()).await;

    match result {
        Ok(success) => {
            assert!(success, "API call should succeed");
        }
        Err(_) => {
            panic!("Test timed out - server not responding");
        }
    }
}

async fn test_real_api_call() -> bool {
    use std::process::Command;

    // Start server in background
    let mut server = Command::new("cargo")
        .args(&["run", "--bin", "ruchy", "--", "notebook", "--port", "8890"])
        .spawn()
        .expect("Failed to start server");

    // Wait for server to start
    tokio::time::sleep(Duration::from_secs(2)).await;

    // Check API call
    let output = Command::new("curl")
        .args(&[
            "-s",
            "-w",
            "%{http_code}",
            "-X",
            "POST",
            "http://localhost:8890/api/execute",
            "-H",
            "Content-Type: application/json",
            "-d",
            r#"{"code":"2 + 2","cell_id":"test","session_id":"test"}"#,
        ])
        .output()
        .expect("Failed to run curl");

    // Kill server
    let _ = server.kill();

    let response = String::from_utf8_lossy(&output.stdout);
    println!("API Response: {}", response);

    // Check if we got 404 (this should FAIL initially)
    !response.contains("404")
}

#[test]
fn test_route_registration_in_code() {
    // This test checks if the route is actually registered in the code

    // Read the server module source
    let source = std::fs::read_to_string("ruchy-notebook/src/server/mod.rs")
        .expect("Could not read server module");

    // Check that the route is actually there
    assert!(
        source.contains("/api/execute"),
        "Route /api/execute not found in server code!"
    );

    assert!(
        source.contains("post(execute_code_handler)"),
        "POST handler for execute_code_handler not found!"
    );

    println!("✅ Route registration found in source code");
}