feat: publish Dever core with project scaffolding and versioned AI skills

test/dever-tests/tests/live_library.rs

@@ -0,0 +1,103 @@
+mod support;
+use support::{checked, rejected, sources, stdout};
+
+const ROUTE: &str = r#"
+route(request: dever.http.Request, reply: dever.system.HttpReply) () recover("connection policy") {
+  dever.sse.start(reply, [])
+  dever.sse.send(reply, dever.sse.Event { event = "tick"
+    data = "hello"
+    id = "1"
+    retry_ms = 1000 })
+}
+public start(listener: dever.system.Listener) () {
+  dever.http.serve_live(route, listener, dever.http.default_limits(), dever.http.default_live_limits())
+}
+"#;
+
+#[test]
+fn live_handler_contract_and_transitive_effects_are_checked() {
+    let source = ROUTE;
+    let map = sources(source);
+    let program = checked(&map);
+    let api = program.api_snapshot();
+    let start = api
+        .lines()
+        .find(|line| line.starts_with("function main.start"))
+        .unwrap();
+    assert!(
+        start.contains("network")
+            && start.contains("concurrency")
+            && start.contains("connection policy"),
+        "{start}"
+    );
+    rejected(
+        &source.replace("dever.system.HttpReply) ()", "dever.system.Socket) ()"),
+        "expected",
+    );
+    rejected(
+        &source.replace(
+            "  dever.sse.start",
+            "  dever.io.println(\"blocked\")\n  dever.sse.start",
+        ),
+        "cannot run inline",
+    );
+}
+
+#[test]
+fn live_example_checks_and_formats_idempotently() {
+    let source = include_str!("../../../examples/old/dever/live_http/module/main.dever");
+    let map = sources(source);
+    checked(&map);
+    let first = dever_core::format::format(&map.files()[0]).unwrap();
+    let second = sources(&first);
+    assert_eq!(
+        dever_core::format::format(&second.files()[0]).unwrap(),
+        first
+    );
+}
+
+#[test]
+fn native_live_server_and_client_cover_stream_sse_and_websocket_resources() {
+    let example = include_str!("../../../examples/old/dever/live_http/module/main.dever");
+    let routes = example.split("\nmain() () {").next().unwrap();
+    let program = format!(
+        r#"{routes}
+checked_response(result: dever.http.ResponseResult.Read(response), expected: Bytes) (ok: Bool) recover("test reports response errors") {{ ok = response.status == 200 and response.body == expected }}
+checked_response(result: dever.http.ResponseResult.Failed(message), expected: Bytes) (ok: Bool) recover("test reports response errors") {{ ok = false }}
+fetch(port: Int, target: Text, expected: Bytes) (ok: Bool) {{
+  request = dever.http.Request {{ method = "GET"
+    target = target
+    headers = [dever.http.header("Host", "test")]
+    body = dever.bytes.from_text("") }}
+  ok = checked_response(result(dever.http.send("127.0.0.1", port, request, dever.http.default_limits())), expected)
+}}
+received(result: dever.websocket.ReceiveResult.Done(state)) (ok: Bool) recover("test reports socket errors") {{ ok = received_state(state) }}
+received(result: other) (ok: Bool) recover("test reports socket errors") {{ ok = false }}
+received_state(state: dever.websocket.ReceiveState.Read(message)) (ok: Bool) {{ ok = text_message(message) }}
+received_state(state: other) (ok: Bool) {{ ok = false }}
+text_message(message: dever.websocket.Message.Text(value)) (ok: Bool) {{ ok = value == "native" }}
+text_message(message: other) (ok: Bool) {{ ok = false }}
+connected(result: dever.websocket.ConnectResult.Connected(socket)) (ok: Bool) recover("test reports socket errors") {{
+  dever.websocket.send(socket, dever.websocket.Message.Text("native"))
+  ok = received(result(dever.websocket.receive(socket)))
+  dever.websocket.close(socket, 1000, "done")
+}}
+connected(result: dever.websocket.ConnectResult.Failed(message)) (ok: Bool) recover("test reports socket errors") {{ ok = false }}
+bound(result: dever.net.PortResult.Bound(port), listener: dever.system.Listener) (ok: Bool) recover("test reports startup errors") {{
+  server = run(dever.http.serve_live(route, listener, dever.http.default_limits(), dever.http.default_live_limits()))
+  normal = fetch(port, "/", dever.bytes.from_text("Dever: /stream, /events, /ws"))
+  stream = fetch(port, "/stream", dever.bytes.from_text("first\nsecond\n"))
+  events = fetch(port, "/events", dever.bytes.from_text("event: tick\nid: 1\nretry: 1000\ndata: 1\n\nevent: tick\nid: 2\nretry: 1000\ndata: 2\n\nevent: tick\nid: 3\nretry: 1000\ndata: 3\n\n"))
+  websocket = connected(result(dever.websocket.connect("127.0.0.1", port, "/ws", dever.websocket.default_limits())))
+  ok = normal and stream and events and websocket
+  stop(server)
+  dever.net.close_listener(listener)
+}}
+bound(result: dever.net.PortResult.Failed(message), listener: dever.system.Listener) (ok: Bool) recover("test reports startup errors") {{ ok = false }}
+listening(result: dever.net.ListenResult.Listening(listener)) (ok: Bool) recover("test reports startup errors") {{ ok = bound(result(dever.net.port(listener)), listener) }}
+listening(result: dever.net.ListenResult.Failed(message)) (ok: Bool) recover("test reports startup errors") {{ ok = false }}
+main() (ok: Bool) {{ ok = listening(result(dever.net.listen("127.0.0.1", 0))) }}
+"#
+    );
+    assert_eq!(stdout(&program), "ok = true\n");
+}