lifetime name change and mode sad path tests

Author: NathanSWard

crates/bevy_ecs/src/system/commands/mod.rs

@@ -82,7 +82,7 @@ impl<'a> Commands<'a> {
     /// }
     /// # example_system.system();
     /// ```
-    pub fn spawn<'b>(&'b mut self) -> EntityCommands<'a, 'b> {
+    pub fn spawn<'this>(&'this mut self) -> EntityCommands<'a, 'this> {
         let entity = self.entities.reserve_entity();
         EntityCommands {
             entity,
@@ -130,7 +130,7 @@ impl<'a> Commands<'a> {
     /// }
     /// # example_system.system();
     /// ```
-    pub fn spawn_bundle<'b, T: Bundle>(&'b mut self, bundle: T) -> EntityCommands<'a, 'b> {
+    pub fn spawn_bundle<'this, T: Bundle>(&'this mut self, bundle: T) -> EntityCommands<'a, 'this> {
         let mut e = self.spawn();
         e.insert_bundle(bundle);
         e
@@ -155,7 +155,7 @@ impl<'a> Commands<'a> {
     /// }
     /// # example_system.system();
     /// ```
-    pub fn entity<'b>(&'b mut self, entity: Entity) -> EntityCommands<'a, 'b> {
+    pub fn entity<'this>(&'this mut self, entity: Entity) -> EntityCommands<'a, 'this> {
         EntityCommands {
             entity,
             commands: self,
@@ -589,7 +589,12 @@ impl<T: Component> FallibleCommand for RemoveResource<T> {
 #[cfg(test)]
 #[allow(clippy::float_cmp, clippy::approx_constant)]
 mod tests {
+    use super::{
+        fallible::FallibleCommand, InsertBundleError, InsertError, RemoveBundleError, RemoveError,
+    };
+    use crate as bevy_ecs;
     use crate::{
+        bundle::Bundle,
         component::{ComponentDescriptor, StorageType},
         entity::Entity,
         system::{CommandQueue, Commands},
@@ -721,8 +726,71 @@ mod tests {
         assert!(world.contains_resource::<f64>());
     }
 
+    struct FailingCommand;
+    impl FallibleCommand for FailingCommand {
+        type Error = ();
+
+        fn try_write(self, _: &mut World) -> Result<(), Self::Error> {
+            Err(())
+        }
+    }
+
+    struct SuccessfulCommand;
+    impl FallibleCommand for SuccessfulCommand {
+        type Error = ();
+
+        fn try_write(self, _: &mut World) -> Result<(), Self::Error> {
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn test_commands_error_handler() {
+        let invoked = Arc::new(AtomicUsize::new(0));
+        let mut world = World::default();
+        let mut queue = CommandQueue::default();
+        {
+            let mut commands = Commands::new(&mut queue, &world);
+
+            commands.insert_resource(42u32);
+            let invoked_clone = invoked.clone();
+            // should succeed
+            commands.remove_resource::<u32>().on_failure(move |_| {
+                invoked_clone.fetch_add(1, Ordering::Relaxed);
+            });
+
+            let invoked_clone = invoked.clone();
+            // should fail
+            commands.remove_resource::<u32>().on_failure(move |_| {
+                invoked_clone.fetch_add(1, Ordering::Relaxed);
+            });
+
+            let invoked_clone = invoked.clone();
+            // should fail
+            commands.add_fallible(FailingCommand).on_failure(move |_| {
+                invoked_clone.fetch_add(1, Ordering::Relaxed);
+            });
+
+            let invoked_clone = invoked.clone();
+            // should succeed
+            commands
+                .add_fallible(SuccessfulCommand)
+                .on_failure(move |_| {
+                    invoked_clone.fetch_add(1, Ordering::Relaxed);
+                });
+        }
+        queue.apply(&mut world);
+
+        assert_eq!(invoked.load(Ordering::Relaxed), 2);
+    }
+
     #[test]
-    fn test_error_handler() {
+    fn test_entity_commands_error_handler() {
+        #[derive(Bundle)]
+        struct TestBundle {
+            value: u32,
+        }
+
         let invoked = Arc::new(AtomicUsize::new(0));
 
         let mut world = World::default();
@@ -734,19 +802,67 @@ mod tests {
         {
             let mut commands = Commands::new(&mut queue, &world);
 
+            // EntityCommands::despawn
             let mut try_despawn = |e| {
                 let invoked_clone = invoked.clone();
-                commands.entity(e).despawn().on_failure(move |_| {
+                commands.entity(e).despawn().on_failure(move |error| {
+                    assert_eq!(error.error.entity, e);
                     invoked_clone.fetch_add(1, Ordering::Relaxed);
                 });
             };
 
             try_despawn(invalid_entity);
             try_despawn(valid_entity);
+
+            // EntityCommands::insert
+            let invoked_clone = invoked.clone();
+            commands
+                .entity(invalid_entity)
+                .insert(42)
+                .on_failure(move |error| {
+                    let InsertError { entity, component } = error.error;
+                    assert_eq!(entity, invalid_entity);
+                    assert_eq!(component, 42);
+                    invoked_clone.fetch_add(1, Ordering::Relaxed);
+                });
+
+            // EntityCommands::insert_bundle
+            let invoked_clone = invoked.clone();
+            commands
+                .entity(invalid_entity)
+                .insert_bundle(TestBundle { value: 42 })
+                .on_failure(move |error| {
+                    let InsertBundleError { entity, bundle } = error.error;
+                    assert_eq!(entity, invalid_entity);
+                    assert_eq!(bundle.value, 42);
+                    invoked_clone.fetch_add(1, Ordering::Relaxed);
+                });
+
+            // EntityCommands::remove
+            let invoked_clone = invoked.clone();
+            commands
+                .entity(invalid_entity)
+                .remove::<u32>()
+                .on_failure(move |error| {
+                    let RemoveError { entity, .. } = error.error;
+                    assert_eq!(entity, invalid_entity);
+                    invoked_clone.fetch_add(1, Ordering::Relaxed);
+                });
+
+            // EntityCommands::remove_resource
+            let invoked_clone = invoked.clone();
+            commands
+                .entity(invalid_entity)
+                .remove_bundle::<TestBundle>()
+                .on_failure(move |error| {
+                    let RemoveBundleError { entity, .. } = error.error;
+                    assert_eq!(entity, invalid_entity);
+                    invoked_clone.fetch_add(1, Ordering::Relaxed);
+                });
         }
         queue.apply(&mut world);
 
-        assert_eq!(invoked.load(Ordering::Relaxed), 1);
+        assert_eq!(invoked.load(Ordering::Relaxed), 5);
     }
 
     #[test]