Create a test to show that only assets which have changed are reprocessed.

Author: andriyDev

crates/bevy_asset/src/processor/tests.rs

@@ -1319,3 +1319,190 @@ fn clears_invalid_data_from_processed_dir() {
     assert!(default_processed_dir.get_dir(empty_dir_subdir).is_none());
     assert!(default_processed_dir.get_dir(empty_dir).is_none());
 }
+
+#[test]
+fn only_reprocesses_wrong_hash_on_startup() {
+    let no_deps_asset = Path::new("no_deps.cool.ron");
+    let source_changed_asset = Path::new("source_changed.cool.ron");
+    let dep_unchanged_asset = Path::new("dep_unchanged.cool.ron");
+    let dep_changed_asset = Path::new("dep_changed.cool.ron");
+    let default_source_dir;
+    let default_processed_dir;
+
+    #[derive(TypePath, Clone)]
+    struct MergeEmbeddedAndAddText;
+
+    impl MutateAsset<CoolText> for MergeEmbeddedAndAddText {
+        fn mutate(&self, asset: &mut CoolText) {
+            asset.text.push_str(" processed");
+            if asset.embedded.is_empty() {
+                return;
+            }
+            asset.text.push(' ');
+            asset.text.push_str(&asset.embedded);
+        }
+    }
+
+    #[derive(TypePath, Clone)]
+    struct Count<T>(Arc<Mutex<u32>>, T);
+
+    impl<A: Asset, T: MutateAsset<A>> MutateAsset<A> for Count<T> {
+        fn mutate(&self, asset: &mut A) {
+            *self.0.lock().unwrap_or_else(PoisonError::into_inner) += 1;
+            self.1.mutate(asset);
+        }
+    }
+
+    let transformer = Count(Arc::new(Mutex::new(0)), MergeEmbeddedAndAddText);
+    type CoolTextProcessor = LoadTransformAndSave<
+        CoolTextLoader,
+        RootAssetTransformer<Count<MergeEmbeddedAndAddText>, CoolText>,
+        CoolTextSaver,
+    >;
+
+    // Create a scope so that the app is completely gone afterwards (and we can see what happens
+    // after reinitializing).
+    {
+        let AppWithProcessor {
+            mut app,
+            source_gate,
+            default_source_dirs,
+            ..
+        } = create_app_with_asset_processor(&[]);
+        default_source_dir = default_source_dirs.source;
+        default_processed_dir = default_source_dirs.processed;
+
+        app.init_asset::<CoolText>()
+            .init_asset::<SubText>()
+            .register_asset_loader(CoolTextLoader)
+            .register_asset_processor(CoolTextProcessor::new(
+                RootAssetTransformer::new(transformer.clone()),
+                CoolTextSaver,
+            ))
+            .set_default_asset_processor::<CoolTextProcessor>("cool.ron");
+
+        let guard = source_gate.write_blocking();
+
+        let cool_text_with_embedded = |text: &str, embedded: &Path| {
+            let cool_text_ron = CoolTextRon {
+                text: text.into(),
+                dependencies: vec![],
+                embedded_dependencies: vec![embedded.to_string_lossy().into_owned()],
+                sub_texts: vec![],
+            };
+            ron::ser::to_string_pretty(&cool_text_ron, PrettyConfig::new().new_line("\n")).unwrap()
+        };
+
+        default_source_dir.insert_asset_text(no_deps_asset, &serialize_as_cool_text("no_deps"));
+        default_source_dir.insert_asset_text(
+            source_changed_asset,
+            &serialize_as_cool_text("source_changed"),
+        );
+        default_source_dir.insert_asset_text(
+            dep_unchanged_asset,
+            &cool_text_with_embedded("dep_unchanged", no_deps_asset),
+        );
+        default_source_dir.insert_asset_text(
+            dep_changed_asset,
+            &cool_text_with_embedded("dep_changed", source_changed_asset),
+        );
+
+        run_app_until_finished_processing(&mut app, guard);
+
+        assert_eq!(
+            read_asset_as_string(&default_processed_dir, no_deps_asset),
+            serialize_as_cool_text("no_deps processed")
+        );
+        assert_eq!(
+            read_asset_as_string(&default_processed_dir, source_changed_asset),
+            serialize_as_cool_text("source_changed processed")
+        );
+        assert_eq!(
+            read_asset_as_string(&default_processed_dir, dep_unchanged_asset),
+            serialize_as_cool_text("dep_unchanged processed no_deps processed")
+        );
+        assert_eq!(
+            read_asset_as_string(&default_processed_dir, dep_changed_asset),
+            serialize_as_cool_text("dep_changed processed source_changed processed")
+        );
+    }
+
+    // Assert and reset the processing count.
+    assert_eq!(
+        core::mem::take(&mut *transformer.0.lock().unwrap_or_else(PoisonError::into_inner)),
+        4
+    );
+
+    // Hand-make the app, since we need to pass in our already existing Dirs from the last app.
+    let mut app = App::new();
+    let source_gate = Arc::new(RwLock::new(()));
+
+    let source_memory_reader = LockGatedReader::new(
+        source_gate.clone(),
+        MemoryAssetReader {
+            root: default_source_dir.clone(),
+        },
+    );
+    let processed_memory_reader = MemoryAssetReader {
+        root: default_processed_dir.clone(),
+    };
+    let processed_memory_writer = MemoryAssetWriter {
+        root: default_processed_dir.clone(),
+    };
+
+    app.register_asset_source(
+        AssetSourceId::Default,
+        AssetSourceBuilder::new(move || Box::new(source_memory_reader.clone()))
+            .with_processed_reader(move || Box::new(processed_memory_reader.clone()))
+            .with_processed_writer(move |_| Some(Box::new(processed_memory_writer.clone()))),
+    );
+
+    app.add_plugins((
+        TaskPoolPlugin::default(),
+        AssetPlugin {
+            mode: AssetMode::Processed,
+            use_asset_processor_override: Some(true),
+            ..Default::default()
+        },
+    ));
+
+    app.init_asset::<CoolText>()
+        .init_asset::<SubText>()
+        .register_asset_loader(CoolTextLoader)
+        .register_asset_processor(CoolTextProcessor::new(
+            RootAssetTransformer::new(transformer.clone()),
+            CoolTextSaver,
+        ))
+        .set_default_asset_processor::<CoolTextProcessor>("cool.ron");
+
+    let guard = source_gate.write_blocking();
+
+    default_source_dir
+        .insert_asset_text(source_changed_asset, &serialize_as_cool_text("DIFFERENT"));
+
+    run_app_until_finished_processing(&mut app, guard);
+
+    // Only source_changed and dep_changed assets were reprocessed - all others still have the same
+    // hashes.
+    assert_eq!(
+        *transformer.0.lock().unwrap_or_else(PoisonError::into_inner),
+        2
+    );
+
+    assert_eq!(
+        read_asset_as_string(&default_processed_dir, no_deps_asset),
+        serialize_as_cool_text("no_deps processed")
+    );
+    assert_eq!(
+        read_asset_as_string(&default_processed_dir, source_changed_asset),
+        serialize_as_cool_text("DIFFERENT processed")
+    );
+    assert_eq!(
+        read_asset_as_string(&default_processed_dir, dep_unchanged_asset),
+        serialize_as_cool_text("dep_unchanged processed no_deps processed")
+    );
+    assert_eq!(
+        read_asset_as_string(&default_processed_dir, dep_changed_asset),
+        serialize_as_cool_text("dep_changed processed DIFFERENT processed")
+    );
+}