test(stack-encrypt): keep the accepted block-ORE index assertion

The shared query-refusal corpus records that the longest text, text with
an interior NUL and empty text are accepted by a block ORE field, but not
which index answers them. Restore the native assertion that the term's
index is IndexSpec::OreBlock, for a single bound and for either bound of
a range, and record it as retained in the coverage map.

Author: coderdan

conformance/stack-encrypt/coverage.md

@@ -200,7 +200,7 @@ in `v1/declarations.json`; `ore-block-between-long-low` and
 | `given_a_field_that_stores_a_null::a_stored_record_may_leave_out_only_a_sql_field` (`record.rs`), removed | `sql-absent-as-required`, `sql-absent-as-sealed` | `read_conformance::shared_record_read_profile` | a missing field tolerated by every null mode: `sql-absent-as-required`, `sql-absent-as-sealed` |
 | `a_query_the_field_does_not_answer_is_refused_naming_the_field` (`src/dynamic/query.rs`), 10 rows, removed | `eq-on-match-only`, `matches-on-equality-only`, `eq-on-order-only`, `lt-text-for-integer`, `lt-fraction-for-integer`, `between-scalar`, `between-one-bound`, `between-mixed-bounds`, `no-such-field` | `query_refusal_conformance::shared_query_refusal_profile` (`check_query` and `query_term` alike) | `operator_not_answered` reported as `unknown_operator`: `eq-on-match-only`; `not_a_range` reported as `field_type`: `between-scalar`; `no_such_field` reported as `unknown_field`: `no-such-field` |
 | `the_typed_paths_query_refusals_are_made_before_any_term` (`query.rs`), 6-row table removed; renamed `folded_equivalents_derive_one_term` for the one-term assertions that stay | `lt-unassigned`, `between-unassigned-high`, `between-unassigned-low`, `matches-too-short`, `matches-unassigned`, `eq-unassigned` | `query_refusal_conformance::shared_query_refusal_profile` | the upper bound of a range not folded before a term: `between-unassigned-high` |
-| `block_ore_refuses_text_it_has_no_term_for_before_any_term` (`query.rs`), removed | `ore-block-too-long`, `ore-block-trailing-nul`, `ore-block-between-long-high`, `ore-block-between-long-low`, `ore-block-between-nul-low`, `ore-block-between-nul-high`; accepted: `ore-block-longest`, `ore-block-interior-nul`, `ore-block-empty` | `query_refusal_conformance::shared_query_refusal_profile` | the length refusal reported as the NUL refusal: `ore-block-too-long` |
+| `block_ore_refuses_text_it_has_no_term_for_before_any_term` (`query.rs`), refusal rows removed; the accepted texts' index assertion stays as `accepted_block_ore_text_derives_a_block_ore_term`, since the corpus records that a case is accepted, not which index answers it | `ore-block-too-long`, `ore-block-trailing-nul`, `ore-block-between-long-high`, `ore-block-between-long-low`, `ore-block-between-nul-low`, `ore-block-between-nul-high` | `query_refusal_conformance::shared_query_refusal_profile` | the length refusal reported as the NUL refusal: `ore-block-too-long` |
 | `TestAQueryTheFieldDoesNotAnswerIsRefused` (`languages/golang/encrypt/query_test.go`), 5-row table, the inverted range and the short match text removed; renamed `TestVerifyAndTargetLimitRefuseWhatIsNotAMatchQuery` for the `Verify`/`TargetLimit` refusals that stay | `matches-on-integer`, `lte-on-match-only`, `unknown-operator`, `between-scalar`, `lt-text-for-integer`, `inverted-range`, `matches-too-short` | `TestQueryRefusalConformance` | the host dropping the diagnostic's `reason`: every refusal case; the engine faults above, through the same engine the guest embeds |
 | `TestAPlanRefusalNamesItsReason` (`languages/golang/encrypt/guest_test.go`), removed | `output-duplicate` as a frame, on both guests (its host plan in `v1/go-declarations.json` is refused by `Validate` before the engine, so the frame is what observes the engine's reason; `TestCheckerRefusesAnIndexedUntypedField` still reaches the engine through `engineCheck`) | `TestDeclarationConformance` | the host dropping the diagnostic's `reason`: `output-duplicate` and every other refusal case |
 

packages/stack-encrypt/src/dynamic/query.rs

@@ -1887,6 +1887,40 @@ mod tests {
         assert_eq!(negative_zero.operand, zero.operand);
     }
 
+    /// Block ORE's refusals and the text it accepts are shared query-refusal
+    /// cases; a refusal table records only that a case is accepted. What
+    /// stays here is which index answers: the longest text, text with an
+    /// interior NUL and empty text derive a block ORE term, either bound of
+    /// a range included.
+    #[tokio::test]
+    async fn accepted_block_ore_text_derives_a_block_ore_term() {
+        let cipher = cipher().await;
+        let keyset = cipher.default_keyset();
+        let plan = record::plan(&frame_of(&Tree::Object(vec![field(
+            "title",
+            "string",
+            vec![text("c"), text("ore_block")],
+        )])))
+        .expect("the plan parses");
+        let one = |text: &str| ValueFrame::of(text).expect("a value");
+        let two = |lo: &str, hi: &str| ValueFrame::of(vec![lo, hi]).expect("a value");
+        let longest = "a".repeat(1023);
+        let accepted = [
+            (OpSpec::Lt, one(&longest)),
+            (OpSpec::Lt, one("a\0b")),
+            (OpSpec::Lt, one("")),
+            (OpSpec::Between, two("", &longest)),
+            (OpSpec::Between, two("a\0b", "b")),
+        ];
+        for (op, input) in accepted {
+            let term = query_term(&keyset, &plan, "title", op, &input, &NoTargets)
+                .expect("a query")
+                .await
+                .expect("a term");
+            assert_eq!(term.index, IndexSpec::OreBlock, "{op:?}");
+        }
+    }
+
     /// A plan whose context is a field of each record has no context a
     /// query could derive under; the binding sends the plan under the
     /// context it names.