ruchy 4.2.0

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! TDD Test to debug why server routes aren't being registered
//! RED: This test captures the exact bug we're seeing

#[tokio::test]
async fn test_server_actually_prints_route_registration() {
    // RED: This will PROVE that the server code isn't being called

    use std::process::{Command, Stdio};
    use std::time::Duration;

    // Start server and capture ALL output
    let mut server = Command::new("cargo")
        .args([
            "run",
            "--bin",
            "ruchy",
            "--features",
            "notebook",
            "--",
            "notebook",
            "--port",
            "9004",
        ])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start server");

    // Wait for server startup
    tokio::time::sleep(Duration::from_secs(5)).await;

    // Kill server and get output
    let _ = server.kill();
    let output = server.wait_with_output().expect("Failed to get output");

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    let combined = format!("{stdout}{stderr}");

    println!("CAPTURED OUTPUT:");
    println!("STDOUT: {stdout}");
    println!("STDERR: {stderr}");

    // This assertion SHOULD pass if the server code is called
    assert!(
        combined.contains("📋 Registering API routes"),
        "BUG DETECTED: Server never prints route registration message!"
    );

    assert!(
        combined.contains("POST /api/execute - Code execution"),
        "BUG DETECTED: Server doesn't register /api/execute endpoint!"
    );
}

#[tokio::test]
async fn test_api_endpoint_returns_404() {
    // RED: This test proves the API endpoint returns 404

    use std::process::{Command, Stdio};
    use std::time::Duration;
    use tokio::time::timeout;

    // Start server
    let mut server = Command::new("cargo")
        .args([
            "run",
            "--bin",
            "ruchy",
            "--features",
            "notebook",
            "--",
            "notebook",
            "--port",
            "9005",
        ])
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn()
        .expect("Failed to start server");

    // Wait for startup
    tokio::time::sleep(Duration::from_secs(4)).await;

    // Check API call
    let client = reqwest::Client::new();
    let response = timeout(
        Duration::from_secs(3),
        client
            .post("http://localhost:9005/api/execute")
            .json(&serde_json::json!({
                "code": "2 + 2",
                "cell_id": "test-cell",
                "session_id": "test-session"
            }))
            .send(),
    )
    .await;

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

    match response {
        Ok(Ok(resp)) => {
            // This assertion will FAIL because we expect 404
            assert_eq!(
                resp.status(),
                404,
                "BUG CONFIRMED: API endpoint returns 404 - routes not registered!"
            );

            println!("✅ BUG CONFIRMED: /api/execute returns 404 as expected");
        }
        Ok(Err(e)) => {
            panic!("Network error: {e}");
        }
        Err(_) => {
            panic!("Request timed out");
        }
    }
}

#[test]
fn test_notebook_feature_flag_enabled() {
    // This test ensures the notebook feature is properly enabled

    // Check that the feature flag is enabled in the build
    #[cfg(feature = "notebook")]
    {
        println!("✅ Notebook feature is enabled");
    }

    #[cfg(not(feature = "notebook"))]
    panic!("❌ BUG: Notebook feature not enabled during test!");
}