Add UnifiedQueryContextTest coverage for the settings bridge

Pins the four behaviors the previous commit introduced:

  * `testLiveSettingsBridgeRespectsClusterRexMaxMatchLimit` — operator's
    cluster-side override (5) wins over the static default (10).
  * `testLiveSettingsAbsentFallsBackToStaticDefault` — pre-bridge behavior
    preserved when the REST handler doesn't supply a live `Settings` instance.
  * `testLiveSettingsNullValueFallsBackToStaticDefault` — pins the `!= null`
    guard in `buildSettings()`; if the live settings instance is supplied but
    has no cluster override for the rex key, the static default still wins.
  * `testLiveSettingsDoNotBridgeOtherKeys` — pins the rex-only scoping
    decision: a cluster override for `QUERY_SIZE_LIMIT` is intentionally
    NOT picked up. Surfaces accidental scope creep (someone widening the
    snapshot to additional keys) as a hard test failure.

Uses a small inline `Settings` stub — the same pattern `buildSettings()` uses
in production code, no Mockito needed.

Signed-off-by: Jialiang Liang <jiallian@amazon.com>

Author: RyanL1997

api/src/test/java/org/opensearch/sql/api/UnifiedQueryContextTest.java

@@ -11,8 +11,12 @@
 import static org.junit.Assert.assertTrue;
 import static org.opensearch.sql.common.setting.Settings.Key.*;
 
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import org.junit.Test;
 import org.opensearch.sql.calcite.SysLimit;
+import org.opensearch.sql.common.setting.Settings;
 import org.opensearch.sql.executor.QueryType;
 
 public class UnifiedQueryContextTest extends UnifiedQueryTestBase {
@@ -83,6 +87,99 @@ public void testInvalidDefaultNamespace() {
         .build();
   }
 
+  @Test
+  public void testLiveSettingsBridgeRespectsClusterRexMaxMatchLimit() {
+    // When the operator has set plugins.ppl.rex.max_match.limit on the cluster,
+    // UnifiedQueryContext should return that value, not the hardcoded 10.
+    Settings live = stubSettings(Map.of(PPL_REX_MAX_MATCH_LIMIT, 5));
+
+    UnifiedQueryContext context =
+        UnifiedQueryContext.builder()
+            .language(QueryType.PPL)
+            .catalog("opensearch", testSchema)
+            .settings(live)
+            .build();
+
+    assertEquals(
+        "Cluster override should win over the static default",
+        Integer.valueOf(5),
+        context.getSettings().getSettingValue(PPL_REX_MAX_MATCH_LIMIT));
+  }
+
+  @Test
+  public void testLiveSettingsAbsentFallsBackToStaticDefault() {
+    // No liveSettings injected — the static default (10) wins. Confirms the
+    // pre-bridge behavior is preserved when the REST handler doesn't supply a
+    // live Settings instance (e.g. in test paths that build the context directly).
+    UnifiedQueryContext context =
+        UnifiedQueryContext.builder()
+            .language(QueryType.PPL)
+            .catalog("opensearch", testSchema)
+            .build();
+
+    assertEquals(
+        "Static default of 10 should win when no liveSettings are injected",
+        Integer.valueOf(10),
+        context.getSettings().getSettingValue(PPL_REX_MAX_MATCH_LIMIT));
+  }
+
+  @Test
+  public void testLiveSettingsNullValueFallsBackToStaticDefault() {
+    // liveSettings injected, but getSettingValue returns null for the rex key
+    // (i.e. the operator has not set a cluster-side override). Static default (10)
+    // should still win — pins the {@code != null} guard in build().
+    Settings live = stubSettings(new HashMap<>());
+
+    UnifiedQueryContext context =
+        UnifiedQueryContext.builder()
+            .language(QueryType.PPL)
+            .catalog("opensearch", testSchema)
+            .settings(live)
+            .build();
+
+    assertEquals(
+        "Static default of 10 should win when liveSettings has no override",
+        Integer.valueOf(10),
+        context.getSettings().getSettingValue(PPL_REX_MAX_MATCH_LIMIT));
+  }
+
+  @Test
+  public void testLiveSettingsDoNotBridgeOtherKeys() {
+    // Pins the rex-only scoping decision: a cluster override for QUERY_SIZE_LIMIT
+    // (or any other key in the static map) is intentionally NOT picked up by
+    // liveSettings. Widening the snapshot is a future scope decision; this test
+    // surfaces accidental scope creep as a hard failure.
+    Settings live = stubSettings(Map.of(QUERY_SIZE_LIMIT, 999));
+
+    UnifiedQueryContext context =
+        UnifiedQueryContext.builder()
+            .language(QueryType.PPL)
+            .catalog("opensearch", testSchema)
+            .settings(live)
+            .build();
+
+    assertEquals(
+        "Static default for QUERY_SIZE_LIMIT should win — bridge is rex-only",
+        Integer.valueOf(SysLimit.DEFAULT.querySizeLimit()),
+        context.getSettings().getSettingValue(QUERY_SIZE_LIMIT));
+  }
+
+  /** Minimal Settings stub: returns values from the supplied map; null for any other key. */
+  private static Settings stubSettings(Map<Settings.Key, Object> values) {
+    return new Settings() {
+      @Override
+      @SuppressWarnings("unchecked")
+      public <T> T getSettingValue(Key key) {
+        return (T) values.get(key);
+      }
+
+      @Override
+      public List<?> getSettings() {
+        return List.copyOf(values.entrySet());
+      }
+    };
+  }
+
   @Test
   public void testContextClose() throws Exception {
     // Create a separate context for this test to avoid affecting other tests