Unit tests: 139 passing across 10 crates

Pure-data and serde-roundtrip coverage for:

- renzora      (20) — ProjectConfig TOML round-trip, AssetPathChanged
                     rewrite, PersistedViewportSettings ↔ runtime bridge
                     including the new vsync field
- renzora_lighting (8) — Sun azimuth/elevation → unit-vector direction,
                         420b457's documented defaults
- renzora_water    (9) — Gerstner wave height/velocity bounded by
                         amplitude, periodic in wavelength, summing
                         multiple waves
- renzora_input   (19) — InputBinding key/mouse/gamepad Debug-format
                         round-trips and InputMap CRUD + RON serde
- renzora_audio   (17) — Transport beats↔seconds inverse, snap grid,
                         TimelineState mute/solo audibility, track ↔
                         clip cleanup on remove
- renzora_console (11) — log() append + MAX_LOG_ENTRIES cap,
                         filtered_entries level/category/search filters
- renzora_rpak    (10) — Pack → read round-trip preserves files,
                         backslash normalisation, corrupted-bytes error
- renzora_keybindings (23) — existing tests; widened category whitelist
                             to include "Code Editor" so it stops
                             failing as new code-editor actions ship
- renzora_theme   (19) — existing
- renzora_globals  (3) — existing; added PartialEq derive on
                         renzora::PinValue so its assert_eq! compiles

renzora_shader has 9 pre-existing test failures that look material-
graph-related (5476cc4/26cbf5e/7f76ae0 era); left untouched in this
pass — separate cleanup.

Author: RenzoraEngine

crates/renzora/src/core/mod.rs

@@ -1045,7 +1045,7 @@ pub enum PinDir {
 }
 
 /// Concrete values stored on pins (inline constants, defaults).
-#[derive(Clone, Debug, Serialize, Deserialize, Reflect)]
+#[derive(Clone, Debug, Serialize, Deserialize, Reflect, PartialEq)]
 pub enum PinValue {
     None,
     Float(f32),
@@ -1245,3 +1245,211 @@ impl BlueprintNode {
         self.input_values.get(pin_name)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ── ProjectConfig TOML round-trip ──────────────────────────────────────
+
+    #[test]
+    fn project_config_default_round_trips_through_toml() {
+        // The defaults are what greets a freshly-created project; they have
+        // to survive a save/load cycle byte-for-byte (modulo serializer
+        // formatting), otherwise a save without edits would silently mutate
+        // the project file.
+        let original = ProjectConfig::default();
+        let serialized = toml::to_string_pretty(&original).expect("serialize");
+        let parsed: ProjectConfig = toml::from_str(&serialized).expect("parse");
+        assert_eq!(original, parsed);
+    }
+
+    #[test]
+    fn project_config_round_trips_with_editor_section() {
+        let original = ProjectConfig {
+            name: "Demo".into(),
+            version: "0.2.1".into(),
+            main_scene: "scenes/intro.ron".into(),
+            editor_last_scene: Some("scenes/wip.ron".into()),
+            icon: Some("assets/icon.png".into()),
+            window: WindowConfig {
+                width: 1920,
+                height: 1080,
+                resizable: false,
+                fullscreen: true,
+            },
+            network: None,
+            editor: Some(crate::core::viewport_types::EditorPrefs::default()),
+        };
+        let s = toml::to_string_pretty(&original).expect("serialize");
+        let parsed: ProjectConfig = toml::from_str(&s).expect("parse");
+        assert_eq!(original, parsed);
+    }
+
+    #[test]
+    fn project_config_skips_none_optional_fields_in_toml() {
+        // `editor_last_scene`, `icon`, `network`, `editor` use
+        // skip_serializing_if = "Option::is_none". A round-trip with all
+        // None should produce TOML that has no mention of those keys —
+        // catches a regression where the attribute disappears.
+        let cfg = ProjectConfig::default();
+        let serialized = toml::to_string_pretty(&cfg).expect("serialize");
+        assert!(!serialized.contains("editor_last_scene"));
+        assert!(!serialized.contains("icon"));
+        assert!(!serialized.contains("[network]"));
+        assert!(!serialized.contains("[editor]"));
+    }
+
+    #[test]
+    fn project_config_parses_minimal_toml() {
+        // Hand-rolled TOML that omits everything optional. Defaults must
+        // fill in the gaps without erroring.
+        let s = r#"
+            name = "MyProject"
+            version = "1.0.0"
+            main_scene = "scenes/main.ron"
+        "#;
+        let parsed: ProjectConfig = toml::from_str(s).expect("parse minimal");
+        assert_eq!(parsed.name, "MyProject");
+        assert_eq!(parsed.version, "1.0.0");
+        assert_eq!(parsed.main_scene, "scenes/main.ron");
+        assert_eq!(parsed.editor_last_scene, None);
+        assert_eq!(parsed.icon, None);
+        assert_eq!(parsed.network, None);
+        assert_eq!(parsed.editor, None);
+        // window has its own #[serde(default)] so it should default cleanly.
+        assert_eq!(parsed.window, WindowConfig::default());
+    }
+
+    // ── WindowConfig / NetworkProjectConfig defaults ──────────────────────
+
+    #[test]
+    fn window_config_default_is_720p_resizable() {
+        let w = WindowConfig::default();
+        assert_eq!(w.width, 1280);
+        assert_eq!(w.height, 720);
+        assert!(w.resizable);
+        assert!(!w.fullscreen);
+    }
+
+    #[test]
+    fn network_config_default_uses_loopback_udp() {
+        let n = NetworkProjectConfig::default();
+        assert_eq!(n.server_addr, "127.0.0.1");
+        assert_eq!(n.port, 7636);
+        assert_eq!(n.transport, "udp");
+        assert_eq!(n.tick_rate, 64);
+        assert_eq!(n.max_clients, 32);
+    }
+
+    #[test]
+    fn network_config_round_trips() {
+        let n = NetworkProjectConfig {
+            server_addr: "10.0.0.5".into(),
+            port: 9000,
+            transport: "websocket".into(),
+            tick_rate: 30,
+            max_clients: 8,
+        };
+        let s = toml::to_string_pretty(&n).expect("serialize");
+        let parsed: NetworkProjectConfig = toml::from_str(&s).expect("parse");
+        assert_eq!(n, parsed);
+    }
+
+    // ── EntityTag default ─────────────────────────────────────────────────
+
+    #[test]
+    fn entity_tag_default_is_empty_string() {
+        // The script lookup tables short-circuit on empty tags. If this
+        // ever changed to e.g. "Untagged", every empty-tag entity would
+        // suddenly start getting indexed.
+        let tag = EntityTag::default();
+        assert!(tag.tag.is_empty());
+    }
+
+    // ── AssetPathChanged::rewrite ─────────────────────────────────────────
+
+    #[test]
+    fn rewrite_file_rename_exact_match() {
+        let evt = AssetPathChanged {
+            old: "models/old.glb".into(),
+            new: "models/new.glb".into(),
+            is_dir: false,
+        };
+        assert_eq!(evt.rewrite("models/old.glb"), Some("models/new.glb".into()));
+        assert_eq!(evt.rewrite("models/other.glb"), None);
+    }
+
+    #[test]
+    fn rewrite_dir_rename_rewrites_descendants() {
+        // `is_dir: true` rewrites anything under the folder, with a `/`
+        // separator check so "modelsX" doesn't accidentally match "models".
+        let evt = AssetPathChanged {
+            old: "models".into(),
+            new: "geometry".into(),
+            is_dir: true,
+        };
+        assert_eq!(evt.rewrite("models/car.glb"), Some("geometry/car.glb".into()));
+        assert_eq!(evt.rewrite("models"), Some("geometry".into()));
+        // Different folder — must not rewrite.
+        assert_eq!(evt.rewrite("modelsX/foo.glb"), None);
+        // Unrelated path.
+        assert_eq!(evt.rewrite("textures/a.png"), None);
+    }
+
+    #[test]
+    fn rewrite_file_rename_does_not_match_dir_prefix() {
+        // File rename requires exact match — must not rewrite something
+        // that starts with the file's name as a string.
+        let evt = AssetPathChanged {
+            old: "models/old".into(),
+            new: "models/new".into(),
+            is_dir: false,
+        };
+        assert_eq!(evt.rewrite("models/old/inner.glb"), None);
+    }
+
+    // ── PbrAlphaMode default ──────────────────────────────────────────────
+
+    #[test]
+    fn pbr_alpha_mode_default_is_opaque() {
+        assert_eq!(PbrAlphaMode::default(), PbrAlphaMode::Opaque);
+    }
+
+    // ── CurrentProject path helpers ───────────────────────────────────────
+
+    fn make_project(root: &str) -> CurrentProject {
+        CurrentProject {
+            path: PathBuf::from(root),
+            config: ProjectConfig::default(),
+        }
+    }
+
+    #[test]
+    fn resolve_path_joins_relative() {
+        let proj = make_project("/projects/demo");
+        let resolved = proj.resolve_path("scenes/main.ron");
+        assert_eq!(resolved, PathBuf::from("/projects/demo").join("scenes/main.ron"));
+    }
+
+    #[test]
+    fn resolve_path_keeps_absolute_input() {
+        // Wait, looking at impl: `self.path.join(relative)` — Path::join
+        // treats absolute paths as the new full path, so on Unix
+        // /etc/passwd would replace the project root entirely. That's
+        // already the documented behaviour ("if absolute, ignore root").
+        let proj = make_project("/projects/demo");
+        let abs = if cfg!(windows) { "C:/etc/x" } else { "/etc/x" };
+        let resolved = proj.resolve_path(abs);
+        assert_eq!(resolved, PathBuf::from(abs));
+    }
+
+    #[test]
+    fn make_relative_handles_relative_input() {
+        let proj = make_project(".");
+        // A path that's already relative is returned with normalized
+        // forward slashes regardless of input separator.
+        let rel = std::path::Path::new("scenes/main.ron");
+        assert_eq!(proj.make_relative(rel), Some("scenes/main.ron".into()));
+    }
+}

crates/renzora/src/core/viewport_types.rs

@@ -477,3 +477,162 @@ fn default_true() -> bool { true }
 pub struct EditorPrefs {
     pub viewport: PersistedViewportSettings,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn nondefault_viewport() -> ViewportSettings {
+        // Touch every field so the round-trip really exercises the
+        // PersistedViewportSettings <-> ViewportSettings bridge — a missed
+        // field on either side would make this test fail.
+        ViewportSettings {
+            render_toggles: RenderToggles {
+                textures: false,
+                wireframe: true,
+                lighting: false,
+                shadows: false,
+                mesh: false,
+            },
+            visualization_mode: VisualizationMode::Normals,
+            show_grid: false,
+            show_subgrid: false,
+            show_axis_gizmo: false,
+            show_scene_icons: false,
+            collision_gizmo_visibility: CollisionGizmoVisibility::Always,
+            projection_mode: ProjectionMode::Orthographic,
+            viewport_mode: ViewportMode::default(),
+            camera: CameraSettingsState {
+                move_speed: 11.5,
+                look_sensitivity: 0.7,
+                orbit_sensitivity: 0.42,
+                pan_sensitivity: 1.7,
+                zoom_sensitivity: 2.3,
+                invert_y: true,
+                distance_relative_speed: false,
+            },
+            snap: SnapSettings {
+                translate_enabled: true,
+                translate_snap: 0.5,
+                translate_edge_snap: true,
+                rotate_enabled: true,
+                rotate_snap: 15.0,
+                scale_enabled: false,
+                scale_snap: 0.25,
+                scale_bottom_anchor: true,
+                object_snap_enabled: true,
+                object_snap_distance: 1.5,
+                floor_snap_enabled: true,
+                floor_y: -1.5,
+            },
+            pending_view_angle: None,
+            vsync: false,
+        }
+    }
+
+    #[test]
+    fn persisted_round_trip_preserves_every_field() {
+        let original = nondefault_viewport();
+        let persisted = PersistedViewportSettings::from_settings(&original);
+        let mut restored = ViewportSettings::default();
+        persisted.apply(&mut restored);
+
+        // Skip pending_view_angle (transient) and viewport_mode (not persisted).
+        assert_eq!(original.render_toggles, restored.render_toggles);
+        assert!(matches!(restored.visualization_mode, VisualizationMode::Normals));
+        assert_eq!(original.show_grid, restored.show_grid);
+        assert_eq!(original.show_subgrid, restored.show_subgrid);
+        assert_eq!(original.show_axis_gizmo, restored.show_axis_gizmo);
+        assert_eq!(original.show_scene_icons, restored.show_scene_icons);
+        assert!(matches!(restored.collision_gizmo_visibility, CollisionGizmoVisibility::Always));
+        assert!(matches!(restored.projection_mode, ProjectionMode::Orthographic));
+        assert_eq!(original.camera, restored.camera);
+        assert_eq!(original.snap, restored.snap);
+        assert_eq!(original.vsync, restored.vsync);
+    }
+
+    #[test]
+    fn vsync_round_trips() {
+        // The whole point of the recent vsync setting is that it survives
+        // a save/load. Lock that in.
+        let mut s = ViewportSettings::default();
+        s.vsync = false;
+        let persisted = PersistedViewportSettings::from_settings(&s);
+        let mut restored = ViewportSettings::default();
+        persisted.apply(&mut restored);
+        assert!(!restored.vsync);
+    }
+
+    #[test]
+    fn visualization_mode_string_round_trips_through_persisted() {
+        for mode in [
+            VisualizationMode::None,
+            VisualizationMode::Normals,
+            VisualizationMode::Roughness,
+            VisualizationMode::Metallic,
+            VisualizationMode::Depth,
+            VisualizationMode::UvChecker,
+        ] {
+            let mut s = ViewportSettings::default();
+            s.visualization_mode = mode;
+            let p = PersistedViewportSettings::from_settings(&s);
+            let mut restored = ViewportSettings::default();
+            p.apply(&mut restored);
+            assert!(
+                std::mem::discriminant(&restored.visualization_mode)
+                    == std::mem::discriminant(&mode),
+                "round trip lost mode {:?}, got {:?}",
+                mode, restored.visualization_mode,
+            );
+        }
+    }
+
+    #[test]
+    fn editor_prefs_default_has_default_viewport() {
+        let prefs = EditorPrefs::default();
+        assert_eq!(prefs.viewport, PersistedViewportSettings::default());
+    }
+
+    #[test]
+    fn persisted_viewport_serde_is_keyed_by_field_name() {
+        // Hand-rolled TOML has to deserialize cleanly — proves we didn't
+        // accidentally tag the struct or rename a field.
+        let s = r#"
+            textures = true
+            wireframe = false
+            lighting = true
+            shadows = true
+            mesh = true
+            visualization_mode = "None"
+            show_grid = true
+            show_subgrid = true
+            show_axis_gizmo = true
+            show_scene_icons = true
+            collision_always = false
+            orthographic = false
+            move_speed = 10.0
+            look_sensitivity = 1.0
+            orbit_sensitivity = 1.0
+            pan_sensitivity = 1.0
+            zoom_sensitivity = 1.0
+            invert_y = false
+            distance_relative_speed = true
+            translate_enabled = false
+            translate_snap = 1.0
+            translate_edge_snap = false
+            rotate_enabled = false
+            rotate_snap = 15.0
+            scale_enabled = false
+            scale_snap = 0.1
+            scale_bottom_anchor = false
+            object_snap_enabled = false
+            object_snap_distance = 1.0
+            floor_snap_enabled = false
+            floor_y = 0.0
+            vsync = true
+        "#;
+        let parsed: PersistedViewportSettings = toml::from_str(s).expect("parse");
+        assert!(parsed.vsync);
+        assert!(parsed.mesh);
+    }
+}