From 634b23ee59515d17aaa579e15202530bf58f06c7 Mon Sep 17 00:00:00 2001
From: Joda <jodainteractive@protonmail.com>
Date: Sat, 27 Dec 2025 01:34:28 -0600
Subject: [PATCH 1/4] add example of a unit test to rainbow-clear-color

---
 examples/rainbow-clear-color.rs | 34 ++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/examples/rainbow-clear-color.rs b/examples/rainbow-clear-color.rs
index db75d01..24aa2c1 100644
--- a/examples/rainbow-clear-color.rs
+++ b/examples/rainbow-clear-color.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 use bevy_pipe_affect::prelude::*;
 
-fn main() {
+fn main() -> AppExit {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_systems(
@@ -9,11 +9,39 @@ fn main() {
             pure(rainbow_clear_color) // pure() is optional, just forces the system to be read-only
                 .pipe(affect),
         )
-        .run();
+        .run()
 }
 
 /// This system defines the clear color as a pure function of time.
-fn rainbow_clear_color(time: Res<Time>) -> impl Effect + use<> {
+fn rainbow_clear_color(time: Res<Time<Real>>) -> ResSet<ClearColor> {
     let color = Color::hsv(time.elapsed_secs() * 20.0, 0.7, 0.7);
     res_set(ClearColor(color))
 }
+
+#[cfg(test)]
+mod tests {
+
+    use bevy::camera::ClearColor;
+    use bevy::color::Color;
+    use bevy::ecs::system::{Res, SystemState};
+    use bevy::ecs::world::World;
+    use bevy::time::{Real, Time};
+
+    use crate::rainbow_clear_color;
+
+    #[test]
+    fn test_rainbow_clear() {
+        // Create a Res<Time> for our system
+        let mut world = World::new();
+        world.insert_resource(Time::new_with(Real::default()));
+
+        let mut state: SystemState<(Res<Time<Real>>,)> = SystemState::new(&mut world);
+        let (time,) = state.get(&mut world);
+
+        // Now that we have a Res<Time>, we can run our system and get an output
+        let output = rainbow_clear_color(time);
+
+        // Then all we have to do is check that output has the proper value
+        assert_eq!(output.value.0, Color::hsva(0.0, 0.7, 0.7, 1.0));
+    }
+}

From 20d044e36bbc934c9964344d0633fa1a2c16d842 Mon Sep 17 00:00:00 2001
From: Joda <jodainteractive@protonmail.com>
Date: Sat, 27 Dec 2025 14:26:13 -0600
Subject: [PATCH 2/4] revert example to use Time and copy to README

---
 README.md                       | 35 ++++++++++++++++++++++++++++++---
 examples/rainbow-clear-color.rs |  6 +++---
 2 files changed, 35 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 07a038c..bb7cc2c 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ All mutability can be _piped out_ of your code.
 use bevy::prelude::*;
 use bevy_pipe_affect::prelude::*;
 
-fn main() {
+fn main() -> AppExit {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_systems(
@@ -25,14 +25,43 @@ fn main() {
             pure(rainbow_clear_color) // pure() is optional, just forces the system to be read-only
                 .pipe(affect),
         )
-        .run();
+        .run()
 }
 
 /// This system defines the clear color as a pure function of time.
-fn rainbow_clear_color(time: Res<Time>) -> impl Effect + use<> {
+fn rainbow_clear_color(time: Res<Time>) -> ResSet<ClearColor> {
     let color = Color::hsv(time.elapsed_secs() * 20.0, 0.7, 0.7);
     res_set(ClearColor(color))
 }
+
+#[cfg(test)]
+mod tests {
+
+    use bevy::camera::ClearColor;
+    use bevy::color::Color;
+    use bevy::ecs::system::{Res, SystemState};
+    use bevy::ecs::world::World;
+    use bevy::time::{Real, Time};
+
+    use crate::rainbow_clear_color;
+
+    #[test]
+    fn test_rainbow_clear() {
+        // Create a Res<Time> for our system
+        let mut world = World::new();
+        world.insert_resource::<Time>(Time::default());
+
+        let mut state: SystemState<(Res<Time>,)> = SystemState::new(&mut world);
+        let (time,) = state.get(&mut world);
+
+        // Now that we have a Res<Time>, we can run our system and get an output
+        let output = rainbow_clear_color(time);
+
+        // Then all we have to do is check that output has the proper value
+        assert_eq!(output.value.0, Color::hsva(0.0, 0.7, 0.7, 1.0));
+    }
+}
+
 ```
 
 ## Documentation
diff --git a/examples/rainbow-clear-color.rs b/examples/rainbow-clear-color.rs
index 24aa2c1..5041ed1 100644
--- a/examples/rainbow-clear-color.rs
+++ b/examples/rainbow-clear-color.rs
@@ -13,7 +13,7 @@ fn main() -> AppExit {
 }
 
 /// This system defines the clear color as a pure function of time.
-fn rainbow_clear_color(time: Res<Time<Real>>) -> ResSet<ClearColor> {
+fn rainbow_clear_color(time: Res<Time>) -> ResSet<ClearColor> {
     let color = Color::hsv(time.elapsed_secs() * 20.0, 0.7, 0.7);
     res_set(ClearColor(color))
 }
@@ -33,9 +33,9 @@ mod tests {
     fn test_rainbow_clear() {
         // Create a Res<Time> for our system
         let mut world = World::new();
-        world.insert_resource(Time::new_with(Real::default()));
+        world.insert_resource::<Time>(Time::default());
 
-        let mut state: SystemState<(Res<Time<Real>>,)> = SystemState::new(&mut world);
+        let mut state: SystemState<(Res<Time>,)> = SystemState::new(&mut world);
         let (time,) = state.get(&mut world);
 
         // Now that we have a Res<Time>, we can run our system and get an output

From e54b4912f8d5a49e52d2fcb207606340a777fd88 Mon Sep 17 00:00:00 2001
From: Joda <jodainteractive@protonmail.com>
Date: Sat, 27 Dec 2025 20:41:22 -0600
Subject: [PATCH 3/4] switch to run_system_once

---
 examples/rainbow-clear-color.rs | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/examples/rainbow-clear-color.rs b/examples/rainbow-clear-color.rs
index 5041ed1..1eb586d 100644
--- a/examples/rainbow-clear-color.rs
+++ b/examples/rainbow-clear-color.rs
@@ -20,26 +20,18 @@ fn rainbow_clear_color(time: Res<Time>) -> ResSet<ClearColor> {
 
 #[cfg(test)]
 mod tests {
+    use bevy::ecs::system::RunSystemOnce;
 
-    use bevy::camera::ClearColor;
-    use bevy::color::Color;
-    use bevy::ecs::system::{Res, SystemState};
-    use bevy::ecs::world::World;
-    use bevy::time::{Real, Time};
-
-    use crate::rainbow_clear_color;
+    use super::*;
 
     #[test]
     fn test_rainbow_clear() {
-        // Create a Res<Time> for our system
+        // Create a World with a Resource for our Time
         let mut world = World::new();
         world.insert_resource::<Time>(Time::default());
 
-        let mut state: SystemState<(Res<Time>,)> = SystemState::new(&mut world);
-        let (time,) = state.get(&mut world);
-
         // Now that we have a Res<Time>, we can run our system and get an output
-        let output = rainbow_clear_color(time);
+        let output = world.run_system_once(rainbow_clear_color).unwrap();
 
         // Then all we have to do is check that output has the proper value
         assert_eq!(output.value.0, Color::hsva(0.0, 0.7, 0.7, 1.0));

From bc4e5c36de0e19eb3e472b42ad2c49d438ce1d93 Mon Sep 17 00:00:00 2001
From: Joda <jodainteractive@protonmail.com>
Date: Sun, 28 Dec 2025 21:23:01 -0600
Subject: [PATCH 4/4] update comments

---
 README.md                       | 21 +++++++--------------
 examples/rainbow-clear-color.rs |  6 ++++--
 2 files changed, 11 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index bb7cc2c..db1cdd1 100644
--- a/README.md
+++ b/README.md
@@ -34,34 +34,27 @@ fn rainbow_clear_color(time: Res<Time>) -> ResSet<ClearColor> {
     res_set(ClearColor(color))
 }
 
+// One benefit of writing systems as pure function is that testing becomes much easier
 #[cfg(test)]
 mod tests {
+    use bevy::ecs::system::RunSystemOnce;
 
-    use bevy::camera::ClearColor;
-    use bevy::color::Color;
-    use bevy::ecs::system::{Res, SystemState};
-    use bevy::ecs::world::World;
-    use bevy::time::{Real, Time};
-
-    use crate::rainbow_clear_color;
+    use super::*;
 
     #[test]
     fn test_rainbow_clear() {
-        // Create a Res<Time> for our system
+        // Create a world to test against
         let mut world = World::new();
         world.insert_resource::<Time>(Time::default());
 
-        let mut state: SystemState<(Res<Time>,)> = SystemState::new(&mut world);
-        let (time,) = state.get(&mut world);
-
         // Now that we have a Res<Time>, we can run our system and get an output
-        let output = rainbow_clear_color(time);
+        let output = world.run_system_once(rainbow_clear_color).unwrap();
 
-        // Then all we have to do is check that output has the proper value
+        // Then, instead of checking that the world and its resources changed in a particular way,
+        // all we have to do is check that the output is correct
         assert_eq!(output.value.0, Color::hsva(0.0, 0.7, 0.7, 1.0));
     }
 }
-
 ```
 
 ## Documentation
diff --git a/examples/rainbow-clear-color.rs b/examples/rainbow-clear-color.rs
index 1eb586d..fb25199 100644
--- a/examples/rainbow-clear-color.rs
+++ b/examples/rainbow-clear-color.rs
@@ -18,6 +18,7 @@ fn rainbow_clear_color(time: Res<Time>) -> ResSet<ClearColor> {
     res_set(ClearColor(color))
 }
 
+// One benefit of writing systems as pure function is that testing becomes much easier
 #[cfg(test)]
 mod tests {
     use bevy::ecs::system::RunSystemOnce;
@@ -26,14 +27,15 @@ mod tests {
 
     #[test]
     fn test_rainbow_clear() {
-        // Create a World with a Resource for our Time
+        // Create a world to test against
         let mut world = World::new();
         world.insert_resource::<Time>(Time::default());
 
         // Now that we have a Res<Time>, we can run our system and get an output
         let output = world.run_system_once(rainbow_clear_color).unwrap();
 
-        // Then all we have to do is check that output has the proper value
+        // Then, instead of checking that the world and its resources changed in a particular way,
+        // all we have to do is check that the output is correct
         assert_eq!(output.value.0, Color::hsva(0.0, 0.7, 0.7, 1.0));
     }
 }