test(stack-encrypt): pin the owned MatchTerms index and ContextExtension inspection

Covers two mutants that survived the in-diff gate: MatchTerms' EncryptTarget::indexes replaced with vec![] (each_owned_term_target_names_its_index, which also pins the other owned terms) and ContextExtension::into_inner replaced with None (a_context_extension_is_inspected_as_supplied_or_omitted). The third survivor, ExpectedContext's omitted replaced with Default::default(), is equivalent: the body is Self::default(). It is excluded in .cargo/mutants.toml beside the matching From<()> entry, with the test that pins the omitted behaviour named.

Author: coderdan

.cargo/mutants.toml

@@ -81,6 +81,11 @@ exclude_re = [
   'stack-encrypt/src/sem/mod\.rs:\d+:\d+: replace <impl MatchConfig for DefaultMatch>::options -> MatchOptions with Default::default\(\)$',
   # Both unit-context conversions explicitly return Self::default().
   'stack-encrypt/src/target/context\.rs:\d+:\d+: replace <impl From<\(\)> for (DeclaredContext|ExpectedContext<T>)>::from -> Self with Default::default\(\)$',
+  # Omitting an expectation is expecting nothing: `ExpectedContext::omitted`
+  # returns Self::default(). That an omitted expectation opens under the
+  # stored context without checking it is pinned by
+  # `a_stored_context_opens_as_stored_and_checks_an_expectation`.
+  'stack-encrypt/src/target/input\.rs:\d+:\d+: replace <impl AllowsNoContext for ExpectedContext<T>>::omitted -> Self with Default::default\(\)$',
   # A caller-free declaration adds nothing to the declared context: the
   # conversion returns Self::default().
   'stack-encrypt/src/target/input\.rs:\d+:\d+: replace <impl From<NoCallerContext> for super::DeclaredContext>::from -> Self with Default::default\(\)$',

packages/stack-encrypt/tests/owned_records.rs

@@ -527,6 +527,45 @@ async fn a_searchable_column_is_one_batch_and_its_terms_match_a_query_term() {
     assert_eq!(retrieves.load(Ordering::SeqCst), 1);
 }
 
+#[test]
+fn each_owned_term_target_names_its_index() {
+    use stack_encrypt::sem::{DefaultMatch, MatchConfig, OpeTerm, OreBlockTerm};
+    use stack_encrypt::IndexSpec;
+    assert_eq!(
+        <EqualityTerm as EncryptTarget<String>>::indexes(),
+        [IndexSpec::Equality]
+    );
+    assert_eq!(
+        <MatchTerms<DefaultMatch> as EncryptTarget<String>>::indexes(),
+        [IndexSpec::Match(DefaultMatch::options())]
+    );
+    assert_eq!(
+        <OreTerm<String> as EncryptTarget<String>>::indexes(),
+        [IndexSpec::Ore]
+    );
+    assert_eq!(
+        <OpeTerm<String> as EncryptTarget<String>>::indexes(),
+        [IndexSpec::Ope]
+    );
+    assert_eq!(
+        <OreBlockTerm<u32> as EncryptTarget<u32>>::indexes(),
+        [IndexSpec::OreBlock]
+    );
+}
+
+#[test]
+fn a_context_extension_is_inspected_as_supplied_or_omitted() {
+    use stack_encrypt::target::AllowsNoContext;
+    assert_eq!(
+        <ContextExtension<u64> as AcceptsContext>::supplied(7).into_inner(),
+        Some(7)
+    );
+    assert_eq!(
+        <ContextExtension<u64> as AllowsNoContext>::omitted().into_inner(),
+        None
+    );
+}
+
 #[tokio::test]
 async fn a_searchable_email_standalone_requires_its_context() {
     let cipher = common::stack_cipher().await;