feat: fluent command assertions

Author: mhedgpeth

crux_core/tests/effect_test_ext.rs

@@ -0,0 +1,126 @@
+//! Negative-case tests for the `EffectTestExt` extension trait that
+//! `#[effect]` generates on `Command<Effect, Event>`.
+
+use serde::{Deserialize, Serialize};
+
+mod app {
+    use crux_core::{
+        App, Command,
+        render::{RenderOperation, render},
+    };
+    use crux_macros::effect;
+    use serde::{Deserialize, Serialize};
+
+    use super::{PingOperation, ping};
+
+    #[derive(Debug, Serialize, Deserialize)]
+    pub enum Event {
+        Render,
+        Ping,
+        Both,
+        Echo(()),
+    }
+
+    #[effect]
+    #[derive(Debug)]
+    pub enum Effect {
+        Render(RenderOperation),
+        Ping(PingOperation),
+    }
+
+    #[derive(Default)]
+    pub struct PanicApp;
+
+    impl App for PanicApp {
+        type Event = Event;
+        type Model = ();
+        type ViewModel = ();
+        type Effect = Effect;
+
+        fn update(&self, event: Self::Event, _model: &mut Self::Model) -> Command<Effect, Event> {
+            match event {
+                Event::Render => render(),
+                Event::Ping => ping().then_send(Event::Echo),
+                Event::Both => render().and(ping().then_send(Event::Echo)),
+                Event::Echo(_) => Command::done(),
+            }
+        }
+
+        fn view(&self, _model: &Self::Model) {}
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct PingOperation;
+
+impl crux_core::capability::Operation for PingOperation {
+    type Output = ();
+}
+
+fn ping() -> crux_core::command::RequestBuilder<
+    app::Effect,
+    app::Event,
+    impl std::future::Future<Output = ()>,
+> {
+    crux_core::Command::request_from_shell(PingOperation)
+}
+
+use app::EffectTestExt as _;
+use crux_core::App as _;
+
+#[test]
+#[should_panic(expected = "expected Render effect but no more effects remain")]
+fn expect_render_panics_on_empty_command() {
+    let mut model = ();
+    app::PanicApp
+        .update(app::Event::Render, &mut model)
+        .expect_render()
+        .expect_render();
+}
+
+#[test]
+#[should_panic(expected = "not a Render effect")]
+fn expect_render_panics_on_wrong_variant() {
+    let mut model = ();
+    app::PanicApp
+        .update(app::Event::Ping, &mut model)
+        .expect_render();
+}
+
+#[test]
+#[should_panic(expected = "expected an event but got none")]
+fn then_event_panics_on_no_events() {
+    let mut model = ();
+    app::PanicApp
+        .update(app::Event::Render, &mut model)
+        .then_event(|_| {});
+}
+
+#[test]
+fn resolve_ping_drives_resulting_event() {
+    let mut model = ();
+    let event = app::PanicApp
+        .update(app::Event::Ping, &mut model)
+        .resolve_ping(|_op| ())
+        .expect_event();
+
+    assert!(matches!(event, app::Event::Echo(())));
+}
+
+#[test]
+fn expect_only_render_succeeds_for_single_render() {
+    let mut model = ();
+    app::PanicApp
+        .update(app::Event::Render, &mut model)
+        .expect_only_render();
+}
+
+#[test]
+#[should_panic(expected = "expected command to be done")]
+fn expect_only_render_panics_with_extra_effects() {
+    let mut model = ();
+    // `Both` emits Render plus a Ping; expect_only_render should reject the leftover.
+    app::PanicApp
+        .update(app::Event::Both, &mut model)
+        .expect_only_render();
+}

crux_macros/src/effect/macro_impl.rs

@@ -152,6 +152,149 @@ pub fn effect_impl(args: Option<Ident>, input: ItemEnum) -> TokenStream {
         }
     });
 
+    let test_ext_trait_ident = format_ident!("{}TestExt", enum_ident);
+
+    let test_ext_trait_methods = effects.clone().map(|effect| {
+        let effect_ident_str = effect.ident.to_string();
+        let effect_ident_snake = effect_ident_str.to_snake_case();
+        let operation = &effect.operation;
+        let expect_fn = Ident::new(&format!("expect_{effect_ident_snake}"), Span::call_site());
+        let expect_with_fn = Ident::new(
+            &format!("expect_{effect_ident_snake}_with"),
+            Span::call_site(),
+        );
+        let expect_only_fn = Ident::new(
+            &format!("expect_only_{effect_ident_snake}"),
+            Span::call_site(),
+        );
+        let expect_only_with_fn = Ident::new(
+            &format!("expect_only_{effect_ident_snake}_with"),
+            Span::call_site(),
+        );
+        let resolve_fn = Ident::new(&format!("resolve_{effect_ident_snake}"), Span::call_site());
+        quote! {
+            fn #expect_fn(&mut self) -> &mut Self;
+            fn #expect_with_fn<F>(&mut self, f: F) -> &mut Self
+            where
+                F: ::core::ops::FnOnce(&#operation);
+            fn #expect_only_fn(&mut self);
+            fn #expect_only_with_fn<F>(&mut self, f: F)
+            where
+                F: ::core::ops::FnOnce(&#operation);
+            fn #resolve_fn<F>(&mut self, f: F) -> &mut Self
+            where
+                F: ::core::ops::FnOnce(&#operation)
+                    -> <#operation as ::crux_core::capability::Operation>::Output;
+        }
+    });
+
+    let test_ext_impl_methods = effects.clone().map(|effect| {
+        let effect_ident_str = effect.ident.to_string();
+        let effect_ident_snake = effect_ident_str.to_snake_case();
+        let operation = &effect.operation;
+        let expect_fn = Ident::new(&format!("expect_{effect_ident_snake}"), Span::call_site());
+        let expect_with_fn = Ident::new(
+            &format!("expect_{effect_ident_snake}_with"),
+            Span::call_site(),
+        );
+        let expect_only_fn = Ident::new(
+            &format!("expect_only_{effect_ident_snake}"),
+            Span::call_site(),
+        );
+        let expect_only_with_fn = Ident::new(
+            &format!("expect_only_{effect_ident_snake}_with"),
+            Span::call_site(),
+        );
+        let resolve_fn = Ident::new(&format!("resolve_{effect_ident_snake}"), Span::call_site());
+        let no_more_msg = format!("expected {effect_ident_str} effect but no more effects remain");
+        quote! {
+            #[track_caller]
+            fn #expect_fn(&mut self) -> &mut Self {
+                let effect = self.effects().next()
+                    .unwrap_or_else(|| panic!(#no_more_msg));
+                let _ = effect.#expect_fn();
+                self
+            }
+
+            #[track_caller]
+            fn #expect_with_fn<F>(&mut self, f: F) -> &mut Self
+            where
+                F: ::core::ops::FnOnce(&#operation),
+            {
+                let effect = self.effects().next()
+                    .unwrap_or_else(|| panic!(#no_more_msg));
+                let req = effect.#expect_fn();
+                f(&req.operation);
+                self
+            }
+
+            #[track_caller]
+            fn #expect_only_fn(&mut self) {
+                let effect = self.effects().next()
+                    .unwrap_or_else(|| panic!(#no_more_msg));
+                let _ = effect.#expect_fn();
+                self.expect_no_effect_or_events();
+            }
+
+            #[track_caller]
+            fn #expect_only_with_fn<F>(&mut self, f: F)
+            where
+                F: ::core::ops::FnOnce(&#operation),
+            {
+                let effect = self.effects().next()
+                    .unwrap_or_else(|| panic!(#no_more_msg));
+                let req = effect.#expect_fn();
+                f(&req.operation);
+                self.expect_no_effect_or_events();
+            }
+
+            #[track_caller]
+            fn #resolve_fn<F>(&mut self, f: F) -> &mut Self
+            where
+                F: ::core::ops::FnOnce(&#operation)
+                    -> <#operation as ::crux_core::capability::Operation>::Output,
+            {
+                let effect = self.effects().next()
+                    .unwrap_or_else(|| panic!(#no_more_msg));
+                let mut req = effect.#expect_fn();
+                let output = f(&req.operation);
+                req.resolve(output).expect("resolve failed");
+                self
+            }
+        }
+    });
+
+    let test_ext = quote! {
+        pub trait #test_ext_trait_ident<Event>
+        where
+            Event: ::core::marker::Send + 'static,
+        {
+            #(#test_ext_trait_methods)*
+
+            fn then_event<F>(&mut self, f: F) -> &mut Self
+            where
+                F: ::core::ops::FnOnce(&Event);
+        }
+
+        impl<Event> #test_ext_trait_ident<Event> for ::crux_core::Command<#enum_ident, Event>
+        where
+            Event: ::core::marker::Send + 'static,
+        {
+            #(#test_ext_impl_methods)*
+
+            #[track_caller]
+            fn then_event<F>(&mut self, f: F) -> &mut Self
+            where
+                F: ::core::ops::FnOnce(&Event),
+            {
+                let ev = self.events().next()
+                    .unwrap_or_else(|| panic!("expected an event but got none"));
+                f(&ev);
+                self
+            }
+        }
+    };
+
     let type_gen = match typegen_kind {
         TypegenKind::Serde => {
             let effect_gen = effects.map(|effect| {
@@ -252,6 +395,8 @@ pub fn effect_impl(args: Option<Ident>, input: ItemEnum) -> TokenStream {
 
         #(#filters)*
 
+        #test_ext
+
         #type_gen
 
     }