create downloads the agent's cached closure before building

hive-c0re/src/job_queue/exec/tests.rs

@@ -834,26 +834,84 @@ async fn provision_and_write_dropin_forward_and_propagate_failure() {
 }
 
 #[tokio::test]
-async fn create_builds_at_the_resolved_rev_then_marks_it_deployed() {
+async fn create_without_a_record_builds_locally_at_the_resolved_rev() {
     let host = FakeHost::up();
-    run_create(&host, "alice").await.expect("ok");
+    run_create(&host, "alice", node_id()).await.expect("ok");
     assert_eq!(
         host.calls(),
         [
             "resolve_meta alice".to_owned(),
+            format!("cached_closure alice {REV}"),
             format!("create_only alice {REV}"),
             format!("mark_deployed alice {REV}"),
         ]
     );
 }
 
+#[tokio::test]
+async fn create_downloads_a_cached_closure_and_builds_nothing() {
+    let host = FakeHost::up().with_closure();
+    let id = node_id();
+    run_create(&host, "alice", id).await.expect("ok");
+    assert_eq!(
+        host.calls(),
+        [
+            "resolve_meta alice".to_owned(),
+            format!("cached_closure alice {REV}"),
+            format!("realise alice {CLOSURE}"),
+            format!("prebuild alice {REV} node={}", id.get()),
+            format!("create_only alice {REV}"),
+            format!("mark_deployed alice {REV}"),
+        ]
+    );
+    assert_eq!(host.builds(), Vec::<String>::new());
+}
+
+#[tokio::test]
+async fn create_builds_locally_when_the_download_fails() {
+    let host = FakeHost::up().with_closure().failing("realise");
+    run_create(&host, "alice", node_id()).await.expect("ok");
+    assert_eq!(
+        host.calls(),
+        [
+            "resolve_meta alice".to_owned(),
+            format!("cached_closure alice {REV}"),
+            format!("realise alice {CLOSURE}"),
+            format!("create_only alice {REV}"),
+            format!("mark_deployed alice {REV}"),
+        ]
+    );
+}
+
+#[tokio::test]
+async fn create_builds_the_evaluated_path_when_it_differs_from_the_download() {
+    let other = "/nix/store/zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz-nixos-system-alice";
+    let host = FakeHost {
+        evaluates: Some(other.to_owned()),
+        ..FakeHost::up().with_closure()
+    };
+    run_create(&host, "alice", node_id()).await.expect("ok");
+    assert_eq!(host.builds(), [other.to_owned()]);
+    let calls = host.calls();
+    assert!(
+        calls
+            .iter()
+            .any(|c| c == &format!("create_only alice {REV}")),
+        "{calls:?}"
+    );
+}
+
 #[tokio::test]
 async fn a_failed_create_is_never_marked_deployed() {
     let host = FakeHost::up().failing("create_only");
-    run_create(&host, "alice").await.expect_err("create fails");
-    assert_eq!(host.calls().len(), 2);
+    run_create(&host, "alice", node_id())
+        .await
+        .expect_err("create fails");
+    assert_eq!(host.calls().len(), 3);
     let host = FakeHost::up().failing("resolve_meta");
-    run_create(&host, "alice").await.expect_err("resolve fails");
+    run_create(&host, "alice", node_id())
+        .await
+        .expect_err("resolve fails");
     assert_eq!(host.calls(), ["resolve_meta alice"]);
 }