Simplify UI tests (#20512)

# Objective

Simplify UI tests by replacing `camera_system` in the test schedule.

Should remove the need for the `bevy_render` dependency in #20502.

## Solution

New `update_cameras_test_system` system that updates each `Camera`'s
render target info directly for UI tests without needing the extra
dependencies and resource inits.

## Testing

Run the tests.

Author: ickshonpe

crates/bevy_ui/src/layout/mod.rs

@@ -352,29 +352,21 @@ pub fn ui_layout_system(
 
 #[cfg(test)]
 mod tests {
+    use crate::update::update_cameras_test_system;
+    use crate::{
+        layout::ui_surface::UiSurface, prelude::*, ui_layout_system,
+        update::propagate_ui_target_cameras, ContentSize, LayoutContext,
+    };
     use bevy_app::{App, HierarchyPropagatePlugin, PostUpdate, PropagateSet};
-    use taffy::TraversePartialTree;
-
-    use bevy_asset::{AssetEvent, Assets};
     use bevy_camera::{Camera, Camera2d};
     use bevy_ecs::{prelude::*, system::RunSystemOnce};
-    use bevy_image::Image;
     use bevy_math::{Rect, UVec2, Vec2};
     use bevy_platform::collections::HashMap;
-    use bevy_render::texture::ManualTextureViews;
     use bevy_transform::systems::mark_dirty_trees;
     use bevy_transform::systems::{propagate_parent_transforms, sync_simple_transforms};
     use bevy_utils::prelude::default;
-    use bevy_window::{
-        PrimaryWindow, Window, WindowCreated, WindowResized, WindowResolution,
-        WindowScaleFactorChanged,
-    };
-    //use uuid::timestamp::UUID_TICKS_BETWEEN_EPOCHS;
-
-    use crate::{
-        layout::ui_surface::UiSurface, prelude::*, ui_layout_system,
-        update::propagate_ui_target_cameras, ContentSize, LayoutContext,
-    };
+    use bevy_window::{PrimaryWindow, Window, WindowResolution};
+    use taffy::TraversePartialTree;
 
     // these window dimensions are easy to convert to and from percentage values
     const WINDOW_WIDTH: f32 = 1000.;
@@ -388,22 +380,14 @@ mod tests {
         ));
         app.init_resource::<UiScale>();
         app.init_resource::<UiSurface>();
-        app.init_resource::<Events<WindowScaleFactorChanged>>();
-        app.init_resource::<Events<WindowResized>>();
-        // Required for the camera system
-        app.init_resource::<Events<WindowCreated>>();
-        app.init_resource::<Events<AssetEvent<Image>>>();
-        app.init_resource::<Assets<Image>>();
-        app.init_resource::<ManualTextureViews>();
         app.init_resource::<bevy_text::TextPipeline>();
         app.init_resource::<bevy_text::CosmicFontSystem>();
         app.init_resource::<bevy_text::SwashCache>();
 
         app.add_systems(
             PostUpdate,
             (
-                // UI is driven by calculated camera target info, so we need to run the camera system first
-                bevy_render::camera::camera_system,
+                update_cameras_test_system,
                 propagate_ui_target_cameras,
                 ApplyDeferred,
                 ui_layout_system,
@@ -1064,14 +1048,7 @@ mod tests {
 
         app.add_systems(
             PostUpdate,
-            (
-                // UI is driven by calculated camera target info, so we need to run the camera system first
-                bevy_render::camera::camera_system,
-                propagate_ui_target_cameras,
-                ApplyDeferred,
-                ui_layout_system,
-            )
-                .chain(),
+            (propagate_ui_target_cameras, ApplyDeferred, ui_layout_system).chain(),
         );
 
         app.add_plugins(HierarchyPropagatePlugin::<ComputedUiTargetCamera>::new(
@@ -1088,29 +1065,13 @@ mod tests {
         let world = app.world_mut();
         world.init_resource::<UiScale>();
         world.init_resource::<UiSurface>();
-        world.init_resource::<Events<WindowScaleFactorChanged>>();
-        world.init_resource::<Events<WindowResized>>();
-        // Required for the camera system
-        world.init_resource::<Events<WindowCreated>>();
-        world.init_resource::<Events<AssetEvent<Image>>>();
-        world.init_resource::<Assets<Image>>();
-        world.init_resource::<ManualTextureViews>();
 
         world.init_resource::<bevy_text::TextPipeline>();
 
         world.init_resource::<bevy_text::CosmicFontSystem>();
 
         world.init_resource::<bevy_text::SwashCache>();
 
-        // spawn a dummy primary window and camera
-        world.spawn((
-            Window {
-                resolution: WindowResolution::new(WINDOW_WIDTH, WINDOW_HEIGHT),
-                ..default()
-            },
-            PrimaryWindow,
-        ));
-
         let ui_root = world
             .spawn(Node {
                 width: Val::Percent(100.),

crates/bevy_ui/src/update.rs

@@ -172,51 +172,64 @@ pub fn propagate_ui_target_cameras(
     }
 }
 
+/// Update each `Camera`'s `RenderTargetInfo` from its associated `Window` render target.
+/// Cameras with non-window render targets are ignored.
+#[cfg(test)]
+pub(crate) fn update_cameras_test_system(
+    primary_window: Query<Entity, bevy_ecs::query::With<bevy_window::PrimaryWindow>>,
+    window_query: Query<&bevy_window::Window>,
+    mut camera_query: Query<&mut Camera>,
+) {
+    let primary_window = primary_window.single().ok();
+    for mut camera in camera_query.iter_mut() {
+        let Some(camera_target) = camera.target.normalize(primary_window) else {
+            continue;
+        };
+        let bevy_camera::NormalizedRenderTarget::Window(window_ref) = camera_target else {
+            continue;
+        };
+        let Ok(window) = window_query.get(bevy_ecs::entity::ContainsEntity::entity(&window_ref))
+        else {
+            continue;
+        };
+
+        let render_target_info = bevy_camera::RenderTargetInfo {
+            physical_size: window.physical_size(),
+            scale_factor: window.scale_factor(),
+        };
+        camera.computed.target_info = Some(render_target_info);
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use crate::update::propagate_ui_target_cameras;
+    use crate::ComputedUiTargetCamera;
+    use crate::IsDefaultUiCamera;
+    use crate::Node;
+    use crate::UiScale;
+    use crate::UiTargetCamera;
     use bevy_app::App;
     use bevy_app::HierarchyPropagatePlugin;
     use bevy_app::PostUpdate;
     use bevy_app::PropagateSet;
-    use bevy_asset::AssetEvent;
-    use bevy_asset::Assets;
     use bevy_camera::Camera;
     use bevy_camera::Camera2d;
     use bevy_camera::RenderTarget;
-    use bevy_ecs::event::Events;
     use bevy_ecs::hierarchy::ChildOf;
     use bevy_ecs::schedule::IntoScheduleConfigs;
-    use bevy_image::Image;
     use bevy_math::UVec2;
-    use bevy_render::texture::ManualTextureViews;
     use bevy_utils::default;
     use bevy_window::PrimaryWindow;
     use bevy_window::Window;
-    use bevy_window::WindowCreated;
     use bevy_window::WindowRef;
-    use bevy_window::WindowResized;
     use bevy_window::WindowResolution;
-    use bevy_window::WindowScaleFactorChanged;
-
-    use crate::update::propagate_ui_target_cameras;
-    use crate::ComputedUiTargetCamera;
-    use crate::IsDefaultUiCamera;
-    use crate::Node;
-    use crate::UiScale;
-    use crate::UiTargetCamera;
 
     fn setup_test_app() -> App {
         let mut app = App::new();
 
         app.init_resource::<UiScale>();
 
-        // init resources required by `camera_system`
-        app.init_resource::<Events<WindowScaleFactorChanged>>();
-        app.init_resource::<Events<WindowResized>>();
-        app.init_resource::<Events<WindowCreated>>();
-        app.init_resource::<Events<AssetEvent<Image>>>();
-        app.init_resource::<Assets<Image>>();
-        app.init_resource::<ManualTextureViews>();
         app.add_plugins(HierarchyPropagatePlugin::<ComputedUiTargetCamera>::new(
             PostUpdate,
         ));
@@ -229,7 +242,7 @@ mod tests {
         app.add_systems(
             bevy_app::Update,
             (
-                bevy_render::camera::camera_system,
+                super::update_cameras_test_system,
                 propagate_ui_target_cameras,
             )
                 .chain(),