WIP prototype migrations

document/migrations/runner/tests/runner.rs

@@ -0,0 +1,145 @@
+use graph_storage::{Attributes, AttributesRead, AttributesWrite, Implementation, Network, Node, PeerId, ROOT_NETWORK, Registry, ResourceId, Session, TimeStamp};
+use migration_core::{
+	ContentMigration, DeclarationInfo, FormatMigration, HistoryPolicy, MigrationContext, MigrationError, MigrationHost, MigrationId, MigrationSet, Payload, PayloadCodec, Selector, Target,
+};
+use migration_runner::{DocumentPayloads, HistoryOutcome, MigrationRunner, RunnerError};
+
+struct NoHost;
+
+impl MigrationHost for NoHost {
+	fn declaration_info(&self, _id: ResourceId) -> Option<DeclarationInfo> {
+		None
+	}
+	fn declaration(&self, _id: ResourceId) -> Option<serde_json::Value> {
+		None
+	}
+	fn resolve_definition(&mut self, _identifier: &str) -> Option<Node> {
+		None
+	}
+}
+
+/// A v1 → v2 format step that renames a top-level registry key, exercising the frozen-shape
+/// decode/encode round trip.
+struct RenameKey;
+
+impl FormatMigration for RenameKey {
+	fn id(&self) -> MigrationId {
+		MigrationId("test-rename-key")
+	}
+	fn migrates_from(&self) -> u32 {
+		1
+	}
+	fn migrate_registry(&self, registry: &Payload) -> Result<Payload, MigrationError> {
+		let mut value: serde_json::Value = registry.decode()?;
+		if let Some(object) = value.as_object_mut()
+			&& let Some(old) = object.remove("old_key")
+		{
+			object.insert("new_key".to_string(), old);
+		}
+		registry.encode_as(&value)
+	}
+	fn history_policy(&self) -> HistoryPolicy {
+		HistoryPolicy::Truncate
+	}
+}
+
+fn format_set() -> MigrationSet {
+	MigrationSet {
+		format: vec![Box::new(RenameKey)],
+		..Default::default()
+	}
+}
+
+#[test]
+fn format_tier_chains_and_bumps_version() {
+	let runner = MigrationRunner::new(vec![format_set()]);
+	let mut payloads = DocumentPayloads {
+		format_version: 1,
+		registry: Payload::encode(&serde_json::json!({ "old_key": 42 }), PayloadCodec::Json).unwrap(),
+		history: vec![Payload::new(vec![1, 2, 3], PayloadCodec::MessagePack)],
+		session: None,
+	};
+
+	let outcome = runner.run_format_migrations(&mut payloads, 2).unwrap();
+
+	assert_eq!(payloads.format_version, 2);
+	assert_eq!(outcome, HistoryOutcome::Truncated);
+	assert!(payloads.history.is_empty());
+	let registry: serde_json::Value = payloads.registry.decode().unwrap();
+	assert_eq!(registry, serde_json::json!({ "new_key": 42 }));
+}
+
+#[test]
+fn format_tier_errors_on_missing_step() {
+	let runner = MigrationRunner::new(vec![format_set()]);
+	let mut payloads = DocumentPayloads {
+		format_version: 0,
+		registry: Payload::encode(&serde_json::json!({}), PayloadCodec::Json).unwrap(),
+		history: Vec::new(),
+		session: None,
+	};
+
+	let error = runner.run_format_migrations(&mut payloads, 2).unwrap_err();
+	assert!(matches!(error, RunnerError::MissingFormatStep { at_version: 0 }));
+}
+
+/// Flags every "Brush"-referenced node with a marker attribute, exercising the delta-expressed
+/// clone-mutate-diff-commit path.
+struct FlagBrushNodes;
+
+impl ContentMigration for FlagBrushNodes {
+	fn id(&self) -> MigrationId {
+		MigrationId("test-flag-brush")
+	}
+	fn selector(&self) -> Selector {
+		Selector::Reference("Brush")
+	}
+	fn migrate(&self, target: Target, registry: &mut Registry, _context: &mut dyn MigrationContext) -> Result<(), MigrationError> {
+		let Target::Node(node_id) = target else { return Ok(()) };
+		let node = registry.node_instances.get_mut(&node_id).ok_or(MigrationError::Invariant("matched node missing".to_string()))?;
+		node.attributes_mut().set("migrated", serde_json::Value::Bool(true), TimeStamp::default());
+		Ok(())
+	}
+}
+
+fn seeded_session() -> (Session, graph_storage::NodeId) {
+	let mut session = Session::with_peer(PeerId(7));
+	let node_id = graph_storage::NodeId(99);
+
+	let mut registry = Registry::default();
+	registry.networks.insert(ROOT_NETWORK, Network::default());
+	let mut attributes = Attributes::new();
+	attributes.set(graph_storage::attr::node::ui::REFERENCE, serde_json::Value::String("Brush".to_string()), TimeStamp::default());
+	registry
+		.node_instances
+		.insert(node_id, Node::new(Implementation::ProtoNode(ResourceId::new()), Vec::new(), attributes, ROOT_NETWORK));
+
+	session.stage_registry_replace(&registry).unwrap();
+	session.retire_all().unwrap();
+
+	(session, node_id)
+}
+
+#[test]
+fn content_tier_commits_migration_as_history_deltas() {
+	let runner = MigrationRunner::new(vec![MigrationSet {
+		content: vec![Box::new(FlagBrushNodes)],
+		..Default::default()
+	}]);
+
+	let (mut session, node_id) = seeded_session();
+	let history_before = session.history().count();
+
+	let revs = runner.run_content_migrations(&mut session, &mut NoHost).unwrap();
+
+	assert!(!revs.is_empty());
+	assert!(session.history().count() > history_before);
+	let node = &session.registry().node_instances[&node_id];
+	assert_eq!(node.attributes().get_typed::<bool>("migrated"), Some(true));
+
+	// Idempotency: a second run matches the same selector but changes nothing, so no new deltas
+	let history_after_first = session.history().count();
+	let revs = runner.run_content_migrations(&mut session, &mut NoHost).unwrap();
+	assert!(revs.is_empty());
+	assert_eq!(session.history().count(), history_after_first);
+}