test: a finished matter and a behind refusal alone are pinned

Two reasons §FS-005-dispatch.27.1 states had no test. `why_not_offered`
on a merged pull request now has to say the matter is finished and name
no selector field, though its recipe's `kinds` would also have refused
it. `Recipe::withheld` against a `behind: true` selector on a branch
level with main has to keep the `behind` refusal, which the offers
reading drops and a recipe named for the matter names.

Author: vjovanov

src/work/mod_tests.rs

@@ -6793,6 +6793,35 @@ fn issue_191_a_plain_run_passes_a_private_plan_over() {
     assert!(named[0].private.is_none());
 }
 
+/// A recipe named for a finished matter is refused because the matter is
+/// finished, not for a selector field that would also have refused it
+/// (§FS-005-dispatch.27.1).
+#[test]
+fn a_recipe_named_for_a_finished_matter_says_the_matter_is_finished() {
+    let tmp = tempfile::tempdir().unwrap();
+    let mut dispatcher = issue_43_dispatcher(tmp.path(), empty_ledger());
+    dispatcher.global.recipes = vec![serde_json::from_value(serde_json::json!({
+        "id": "issue-work", "description": "work the issue", "brief": "Work {title}.",
+        "needs_checkout": false, "when": { "kinds": ["issue"] }
+    }))
+    .unwrap()];
+    let mut merged = issue_43_item();
+    merged.kind = crate::feed::model::ItemKind::Pr;
+    merged.state = Some("merged".to_string());
+    assert!(merged.is_finished());
+
+    let says = dispatcher.why_not_offered(&merged, "issue-work");
+    assert!(
+        says.contains("issue-work") && says.contains(&merged.id),
+        "{says}"
+    );
+    assert!(says.contains("finished"), "{says}");
+    assert!(
+        !says.contains("selector") && !says.contains("kind"),
+        "a selector field was named for a finished matter: {says}"
+    );
+}
+
 /// A name that is a workflow entry rather than a recipe is pointed at the door
 /// that lays it, not told it is unconfigured (§FS-005-dispatch.27.1).
 #[test]

src/work/recipe.rs

@@ -2230,6 +2230,35 @@ mod tests {
         assert!(!level.matches(&pr, &Facts::default()));
     }
 
+    /// What withholds a recipe keeps `behind` refusing alone: the offers
+    /// reading drops it, and a recipe named for the matter names it
+    /// (§FS-005-dispatch.27.1).
+    #[test]
+    fn a_behind_refusal_alone_is_kept_among_what_withholds_a_recipe() {
+        let trailing = serde_json::from_value::<Recipe>(json!({
+            "id": "trailing", "description": "replay it", "brief": "Replay {title}.",
+            "when": { "behind": true }
+        }))
+        .unwrap();
+        let level = Facts {
+            behind: Some(0),
+            ..Facts::default()
+        };
+        let refused = trailing.withheld(&item(ItemKind::Pr, None), &level, None);
+        assert_eq!(
+            refused
+                .iter()
+                .map(|refusal| refusal.field)
+                .collect::<Vec<_>>(),
+            ["behind"]
+        );
+        assert!(
+            refused[0].reason.contains("level with"),
+            "{}",
+            refused[0].reason
+        );
+    }
+
     /// The other distance is asked about in the same words, and answered from
     /// the same fold (§FS-004-quick-actions.8). The two are separate
     /// questions: a branch level with main can be well behind its own copy.