fix(client): preserve normalized request ownership

crates/wip-client/tests/runtime.rs

@@ -202,6 +202,94 @@ fn normalized_object_cache_rejects_conflicts_and_evicts_to_its_bound() {
     assert!(client.object(&session, "/third").is_some());
 }
 
+#[test]
+fn normalized_aliases_preserve_newer_request_ownership() {
+    let mut client = client(8, 8, 8, 8);
+    let session = client
+        .open_session("https://example.test/wip", SecurityContext::new("subject"))
+        .unwrap();
+    observe_object(
+        &mut client,
+        &session,
+        "/a/shared",
+        object("shared", Some("shared-ref"), b"initial"),
+    );
+    observe_object(
+        &mut client,
+        &session,
+        "/b/shared",
+        object("shared", Some("shared-ref"), b"initial"),
+    );
+    let request = FetchTreeRequest {
+        path: "/a".into(),
+        depth: 1,
+        limit: 4,
+    };
+    let older_tree_response = || FetchTreeResponse {
+        root: ObjectTreeNode {
+            object: object("a", None, b"root"),
+            children: vec![ObjectTreeNode {
+                object: object("shared", Some("shared-ref"), b"older"),
+                children: vec![],
+            }],
+        },
+        truncated: false,
+    };
+
+    let older_tree = client.prepare_tree(&session, "/a", 1, 4).unwrap();
+    let newer_alias = client.prepare_fetch(&session, "/b/shared").unwrap();
+    client
+        .complete(
+            newer_alias.id,
+            fetch_response("/b/shared", &object("shared", Some("shared-ref"), b"newer")),
+        )
+        .unwrap();
+    client
+        .complete(
+            older_tree.id,
+            encode_fetch_tree_response(&request, &older_tree_response(), wire_limits()).unwrap(),
+        )
+        .unwrap();
+    assert_eq!(
+        client.object(&session, "/a/shared").unwrap().validator,
+        Some(b"newer".to_vec())
+    );
+    assert_eq!(
+        client.object(&session, "/b/shared").unwrap().validator,
+        Some(b"newer".to_vec())
+    );
+
+    let older_tree = client.prepare_tree(&session, "/a", 1, 4).unwrap();
+    let newer_alias = client.prepare_fetch(&session, "/b/shared").unwrap();
+    client
+        .complete(
+            older_tree.id,
+            encode_fetch_tree_response(&request, &older_tree_response(), wire_limits()).unwrap(),
+        )
+        .unwrap();
+    assert!(matches!(
+        client.object(&session, "/b/shared").unwrap().state,
+        ObservationState::Loading(id) if id == newer_alias.id
+    ));
+    assert_eq!(
+        client.object(&session, "/b/shared").unwrap().validator,
+        Some(b"newer".to_vec())
+    );
+    client
+        .complete(
+            newer_alias.id,
+            fetch_response(
+                "/b/shared",
+                &object("shared", Some("shared-ref"), b"newest"),
+            ),
+        )
+        .unwrap();
+    assert_eq!(
+        client.object(&session, "/a/shared").unwrap().validator,
+        Some(b"newest".to_vec())
+    );
+}
+
 #[test]
 fn tree_expansion_is_lazy_truncated_and_refreshes_edges() {
     let mut client = client(16, 8, 8, 8);
@@ -595,6 +683,15 @@ fn overlapping_tree_work_preserves_newer_subject_request_ownership() {
         client.tree(&session, "/child").unwrap().state,
         ObservationState::Loading(id) if id == newer_child_tree.id
     ));
+    let child_observation = client.object(&session, "/child").unwrap();
+    assert!(matches!(
+        child_observation.state,
+        ObservationState::Loading(id) if id == newer_child_tree.id
+    ));
+    assert_eq!(
+        child_observation.validator,
+        Some(b"newer-than-omission".to_vec())
+    );
     let child_request = FetchTreeRequest {
         path: "/child".into(),
         depth: 0,
@@ -857,7 +954,6 @@ fn failed_entry_and_tree_observation_metadata_is_bounded() {
         );
     }
     assert!(client.tree(&session, "/alpha").is_none());
-    assert!(client.tree(&session, "/beta").is_some());
     assert!(client.tree(&session, "/gamma").is_some());
 }