Create tests to show that dropping handles can cancel loads. (#21518)

# Objective

- Make sure we don't lose the ability to cancel a load when dropping
handles.

## Solution

- Add tests!

## Testing

- Yes!

Author: andriyDev

crates/bevy_asset/src/lib.rs

@@ -2085,6 +2085,151 @@ mod tests {
         );
     }
 
+    /// A loader that notifies a sender when the loader has started, and blocks on a receiver to
+    /// simulate a long asset loader.
+    // Note: we can't just use the GatedReader, since currently we hold the handle until after
+    // we've selected the reader. The GatedReader blocks this process, so we need to wait until
+    // we gate in the loader instead.
+    struct GatedLoader {
+        in_loader_sender: async_channel::Sender<()>,
+        gate_receiver: async_channel::Receiver<()>,
+    }
+
+    impl AssetLoader for GatedLoader {
+        type Asset = TestAsset;
+        type Error = std::io::Error;
+        type Settings = ();
+
+        async fn load(
+            &self,
+            _reader: &mut dyn Reader,
+            _settings: &Self::Settings,
+            _load_context: &mut LoadContext<'_>,
+        ) -> Result<Self::Asset, Self::Error> {
+            self.in_loader_sender.send_blocking(()).unwrap();
+            let _ = self.gate_receiver.recv().await;
+            Ok(TestAsset)
+        }
+
+        fn extensions(&self) -> &[&str] {
+            &["ron"]
+        }
+    }
+
+    #[test]
+    fn dropping_handle_while_loading_cancels_load() {
+        let dir = Dir::default();
+        let mut app = App::new();
+        let reader = MemoryAssetReader { root: dir.clone() };
+        app.register_asset_source(
+            AssetSourceId::Default,
+            AssetSource::build().with_reader(move || Box::new(reader.clone())),
+        )
+        .add_plugins((TaskPoolPlugin::default(), AssetPlugin::default()));
+
+        let (in_loader_sender, in_loader_receiver) = async_channel::bounded(1);
+        let (gate_sender, gate_receiver) = async_channel::bounded(1);
+
+        app.init_asset::<TestAsset>()
+            .register_asset_loader(GatedLoader {
+                in_loader_sender,
+                gate_receiver,
+            });
+
+        let path = Path::new("abc.ron");
+        dir.insert_asset_text(path, "blah");
+
+        let asset_server = app.world().resource::<AssetServer>().clone();
+
+        // Start loading the asset. This load will get blocked by the gate.
+        let handle = asset_server.load::<TestAsset>(path);
+        assert!(asset_server.get_load_state(&handle).unwrap().is_loading());
+        app.update();
+
+        // Make sure we are inside the loader before continuing.
+        in_loader_receiver.recv_blocking().unwrap();
+
+        let asset_id = handle.id();
+        // Dropping the handle and doing another update should result in the load being cancelled.
+        drop(handle);
+        app.update();
+        assert!(asset_server.get_load_state(asset_id).is_none());
+
+        // Unblock the loader and then update a few times, showing that the asset never loads.
+        gate_sender.send_blocking(()).unwrap();
+        for _ in 0..10 {
+            app.update();
+            for message in app
+                .world()
+                .resource::<Messages<AssetEvent<TestAsset>>>()
+                .iter_current_update_messages()
+            {
+                match message {
+                    AssetEvent::Unused { .. } => {}
+                    message => panic!("No asset events are allowed: {message:?}"),
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn dropping_subasset_handle_while_loading_cancels_load() {
+        let dir = Dir::default();
+        let mut app = App::new();
+        let reader = MemoryAssetReader { root: dir.clone() };
+        app.register_asset_source(
+            AssetSourceId::Default,
+            AssetSource::build().with_reader(move || Box::new(reader.clone())),
+        )
+        .add_plugins((TaskPoolPlugin::default(), AssetPlugin::default()));
+
+        let (in_loader_sender, in_loader_receiver) = async_channel::bounded(1);
+        let (gate_sender, gate_receiver) = async_channel::bounded(1);
+
+        app.init_asset::<TestAsset>()
+            .register_asset_loader(GatedLoader {
+                in_loader_sender,
+                gate_receiver,
+            });
+
+        let path = Path::new("abc.ron");
+        dir.insert_asset_text(path, "blah");
+
+        let asset_server = app.world().resource::<AssetServer>().clone();
+
+        // Start loading the subasset. This load will get blocked by the gate.
+        // Note: it doesn't matter that the subasset doesn't actually end up existing, since the
+        // asset system doesn't know that until after the load completes, which we cancel anyway.
+        let handle = asset_server.load::<TestAsset>("abc.ron#sub");
+        assert!(asset_server.get_load_state(&handle).unwrap().is_loading());
+        app.update();
+
+        // Make sure we are inside the loader before continuing.
+        in_loader_receiver.recv_blocking().unwrap();
+
+        let asset_id = handle.id();
+        // Dropping the handle and doing another update should result in the load being cancelled.
+        drop(handle);
+        app.update();
+        assert!(asset_server.get_load_state(asset_id).is_none());
+
+        // Unblock the loader and then update a few times, showing that the asset never loads.
+        gate_sender.send_blocking(()).unwrap();
+        for _ in 0..10 {
+            app.update();
+            for message in app
+                .world()
+                .resource::<Messages<AssetEvent<TestAsset>>>()
+                .iter_current_update_messages()
+            {
+                match message {
+                    AssetEvent::Unused { .. } => {}
+                    message => panic!("No asset events are allowed: {message:?}"),
+                }
+            }
+        }
+    }
+
     // Creates a basic app with the default asset source engineered to get back the asset event
     // sender.
     fn create_app_with_source_event_sender() -> (App, Dir, Sender<AssetSourceEvent>) {