kobako 0.28.0 → 0.30.0

data/crates/kobako-wasmtime/tests/integration/main.rs

@@ -0,0 +1,29 @@
+//! The driver's integration tests, built as one binary so a run links
+//! wasmtime once rather than once per file.
+
+mod support;
+
+mod compile_posture;
+mod guest_file;
+mod preamble_flags;
+mod snippet_compile;
+mod unanswered_call;
+mod unsupported_call;
+
+// Cargo compiles only the modules declared above, so a test file left out
+// would never run and nothing would say so.
+#[test]
+fn every_file_in_this_directory_is_a_declared_module() {
+    let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/integration");
+    for entry in std::fs::read_dir(dir).expect("the test directory must list") {
+        let path = entry.expect("an entry must read").path();
+        let name = path
+            .file_stem()
+            .and_then(|stem| stem.to_str())
+            .expect("a UTF-8 name");
+        assert!(
+            name == "main" || include_str!("main.rs").contains(&format!("mod {name};")),
+            "tests/integration/{name} must be declared in main.rs, or it never runs"
+        );
+    }
+}

data/crates/kobako-wasmtime/tests/{preamble_flags.rs → integration/preamble_flags.rs}

@@ -1,8 +1,8 @@
-//! The bundled guest recognises no flag, so every flag a host sets meets
-//! the unrecognised path: a critical one must refuse the invocation under
+//! A flag the bundled guest does not recognise meets the unrecognised
+//! path: a critical one must refuse the invocation under
 //! its own class, and an advisory one must leave the run untouched.
 
-mod support;
+use crate::support;
 
 use kobako_runtime::{Completion, Entry, Runtime};
 use kobako_transport::envelope::{Flag, Origin, Outcome, Preamble};
@@ -26,6 +26,7 @@ fn eval_with_flag(critical: bool) -> Option<(Outcome, Vec<u8>)> {
             },
             &preamble,
             None,
+            &[],
         )
         .expect("the invocation must start");
     let Completion::Outcome(outcome) = snapshot.completion else {

data/crates/kobako-wasmtime/tests/{snippet_compile.rs → integration/snippet_compile.rs}

@@ -4,21 +4,21 @@
 //! two compiles of the same Preamble have to agree byte for byte so
 //! either can stand in for the other.
 
-mod support;
+use crate::support;
 
 use kobako_runtime::{Completion, Entry, Runtime};
 use kobako_transport::envelope::{Flag, Outcome, Preamble, Snippet, Snippets};
 
 use support::bundled_driver as driver;
 
-fn preamble_of(entries: Vec<Snippet>) -> Preamble {
+fn preamble_with(entries: Vec<Snippet>) -> Preamble {
     let mut preamble = Preamble::default();
     preamble.snippets = Snippets { entries };
     preamble
 }
 
 fn greeter() -> Preamble {
-    preamble_of(vec![Snippet::Source {
+    preamble_with(vec![Snippet::Source {
         name: "Greeter".into(),
         body: "module Greeter; def self.hi = 'hi'; end".into(),
     }])
@@ -33,7 +33,7 @@ fn compiled_snippets_replay_in_a_later_invocation() {
     let bytecodes = driver
         .compile(&greeter())
         .expect("a source snippet that parses must compile");
-    let replay = preamble_of(
+    let replay = preamble_with(
         bytecodes
             .into_iter()
             .map(|body| Snippet::Bytecode { body })
@@ -47,6 +47,7 @@ fn compiled_snippets_replay_in_a_later_invocation() {
             },
             &replay,
             None,
+            &[],
         )
         .expect("the invocation must start");
 

data/crates/kobako-wasmtime/tests/{support → integration/support}/mod.rs

@@ -18,17 +18,13 @@ pub fn bundled_driver() -> Option<Driver> {
         );
         return None;
     }
-    Some(
-        Driver::new(
-            Path::new(WASM),
-            Config {
-                timeout: Some(Duration::from_secs(10)),
-                memory_limit: None,
-                stdout_limit: None,
-                stderr_limit: None,
-                profile: Profile::Hermetic,
-            },
-        )
-        .expect("the Guest Binary must load"),
-    )
+    let mut config = Config::default();
+    config.timeout = Some(Duration::from_secs(10));
+    config.setup_timeout = Some(Duration::from_secs(10));
+    config.memory_limit = None;
+    config.stdout_limit = None;
+    config.stderr_limit = None;
+    config.open_file_limit = None;
+    config.profile = Profile::Hermetic;
+    Some(Driver::new(Path::new(WASM), config).expect("the Guest Binary must load"))
 }

data/crates/kobako-wasmtime/tests/integration/unanswered_call.rs

@@ -0,0 +1,86 @@
+//! A Call the host could not answer as the Service meant still reaches the
+//! guest as an answer it can rescue, and the answer says why. The default
+//! frontends never hand the driver either failure, so only a handler
+//! written here reaches them.
+
+use crate::support;
+
+use std::sync::Arc;
+
+use kobako_runtime::{Completion, DispatchHandler, Entry, Runtime, Yielder};
+use kobako_transport::envelope::{Bindings, Call, Outcome, Preamble, Reply};
+
+/// Answers every Call with one byte more than a message carries.
+struct AnswersTooMuch;
+
+impl DispatchHandler for AnswersTooMuch {
+    fn dispatch(&self, _call: Call<'_>, _yielder: &mut dyn Yielder) -> Option<Reply> {
+        Some(Reply::Ok(vec![0xc0; (16 << 20) + 1]))
+    }
+}
+
+/// Breaks the handler contract by answering nothing.
+struct AnswersNothing;
+
+impl DispatchHandler for AnswersNothing {
+    fn dispatch(&self, _call: Call<'_>, _yielder: &mut dyn Yielder) -> Option<Reply> {
+        None
+    }
+}
+
+fn eval_against(handler: Arc<dyn DispatchHandler>, source: &[u8]) -> Option<Outcome> {
+    let driver = support::bundled_driver()?;
+    let mut preamble = Preamble::default();
+    preamble.bindings = Bindings {
+        paths: vec!["Svc".into()],
+    };
+    let snapshot = driver
+        .invoke(Entry::Eval { source }, &preamble, Some(handler), &[])
+        .expect("the invocation must start");
+    let Completion::Outcome(outcome) = snapshot.completion else {
+        panic!("the invocation must answer rather than trap");
+    };
+    Some(outcome)
+}
+
+// @behavior T-286
+#[test]
+fn an_answer_larger_than_a_message_raises_a_service_failure_naming_the_limit() {
+    let source = b"begin; Svc.go; rescue Kobako::ServiceError => e; e.message; end";
+    let Some(outcome) = eval_against(Arc::new(AnswersTooMuch), source) else {
+        return;
+    };
+
+    let mut expected = vec![0xd9, 0x4e];
+    expected.extend_from_slice(
+        b"Sandbox could not write the Service's answer: payload exceeds the 16 MiB limit",
+    );
+    assert_eq!(
+        outcome,
+        Outcome::Ok(expected),
+        "a Service answer past the message cap through Driver#invoke must raise a Service \
+         failure in the guest naming the limit"
+    );
+}
+
+// @behavior T-287
+#[test]
+fn a_call_the_host_could_not_answer_raises_a_transport_error_naming_why() {
+    let source = b"begin; Svc.go; rescue Kobako::Transport::Error => e; e.message; end";
+    let Some(outcome) = eval_against(Arc::new(AnswersNothing), source) else {
+        return;
+    };
+
+    let mut expected = vec![0xd9, 0x6a];
+    expected.extend_from_slice(
+        "a Sandbox callback raised an exception instead of returning a fault — please report \
+         this as a kobako bug"
+            .as_bytes(),
+    );
+    assert_eq!(
+        outcome,
+        Outcome::Ok(expected),
+        "a Call a handler answered with nothing through Driver#invoke must raise \
+         Kobako::Transport::Error in the guest naming why"
+    );
+}

data/crates/kobako-wasmtime/tests/{unsupported_call.rs → integration/unsupported_call.rs}

@@ -3,7 +3,7 @@
 //! rather than a broken exchange. The default frontends serve every Call,
 //! so only a handler written here reaches that answer.
 
-mod support;
+use crate::support;
 
 use std::sync::Arc;
 
@@ -35,6 +35,7 @@ fn a_call_the_host_does_not_serve_raises_unsupported_error_in_the_guest() {
             Entry::Eval { source },
             &preamble,
             Some(Arc::new(ServesNoCall)),
+            &[],
         )
         .expect("the invocation must start");