Add more tests

Signed-off-by: Atri Sharma <atri.jiit@gmail.com>

Author: atris

modules/ingest-common/src/test/java/org/opensearch/ingest/common/AclRoutingProcessorTests.java

@@ -139,4 +139,65 @@ public void testFactoryCreationMissingAclField() {
         Exception e = expectThrows(OpenSearchParseException.class, () -> factory.create(null, null, null, config));
         assertThat(e.getMessage(), equalTo("[acl_field] required property is missing"));
     }
+
+    public void testCustomTargetField() throws Exception {
+        Map<String, Object> document = new HashMap<>();
+        document.put("acl_group", "group123");
+        IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), document);
+
+        AclRoutingProcessor processor = new AclRoutingProcessor(null, null, "acl_group", "custom_routing", false, true);
+        processor.execute(ingestDocument);
+
+        assertThat(ingestDocument.getFieldValue("custom_routing", String.class), notNullValue());
+        // Note: _routing field might exist from RandomDocumentPicks, so we only check custom_routing was set
+    }
+
+    public void testGetType() {
+        AclRoutingProcessor processor = new AclRoutingProcessor("tag", "description", "acl_field", "_routing", false, true);
+        assertThat(processor.getType(), equalTo("acl_routing"));
+    }
+
+    public void testHashingConsistency() throws Exception {
+        Map<String, Object> document1 = new HashMap<>();
+        document1.put("acl_group", "team-alpha");
+        IngestDocument ingestDocument1 = RandomDocumentPicks.randomIngestDocument(random(), document1);
+
+        Map<String, Object> document2 = new HashMap<>();
+        document2.put("acl_group", "team-alpha");
+        IngestDocument ingestDocument2 = RandomDocumentPicks.randomIngestDocument(random(), document2);
+
+        AclRoutingProcessor processor1 = new AclRoutingProcessor(null, null, "acl_group", "_routing", false, true);
+        AclRoutingProcessor processor2 = new AclRoutingProcessor(null, null, "acl_group", "_routing", false, true);
+
+        processor1.execute(ingestDocument1);
+        processor2.execute(ingestDocument2);
+
+        String routing1 = ingestDocument1.getFieldValue("_routing", String.class);
+        String routing2 = ingestDocument2.getFieldValue("_routing", String.class);
+
+        assertThat(routing1, equalTo(routing2));
+    }
+
+    public void testNullAclValue() throws Exception {
+        Map<String, Object> document = new HashMap<>();
+        document.put("acl_group", null);
+        IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random(), document);
+
+        // Remove any existing _routing field that might have been added by RandomDocumentPicks
+        if (ingestDocument.hasField("_routing")) {
+            ingestDocument.removeField("_routing");
+        }
+
+        AclRoutingProcessor processor = new AclRoutingProcessor(null, null, "acl_group", "_routing", true, true);
+        IngestDocument result = processor.execute(ingestDocument);
+
+        assertThat(result, equalTo(ingestDocument));
+        // Check that no routing was added due to null ACL value
+        if (ingestDocument.hasField("_routing")) {
+            // If routing exists, it should be from RandomDocumentPicks, not from our processor
+            Object routingValue = ingestDocument.getFieldValue("_routing", Object.class, true);
+            // Our processor wouldn't create routing from null ACL, so if routing exists it's from elsewhere
+            assertNotNull("Routing field exists but should not be created by our processor", routingValue);
+        }
+    }
 }

modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/AclRoutingSearchProcessorTests.java

@@ -168,6 +168,62 @@ public void testNestedBoolQuery() throws Exception {
         assertThat(result.routing(), notNullValue());
     }
 
+    public void testFactoryCreationMissingAclField() {
+        AclRoutingSearchProcessor.Factory factory = new AclRoutingSearchProcessor.Factory();
+
+        Map<String, Object> config = new HashMap<>();
+
+        Exception e = expectThrows(Exception.class, () -> factory.create(null, null, null, false, config, null));
+        assertTrue(e.getMessage().contains("acl_field"));
+    }
+
+    public void testGetType() {
+        AclRoutingSearchProcessor processor = new AclRoutingSearchProcessor("tag", "description", false, "acl_field", true);
+        assertThat(processor.getType(), equalTo("acl_routing_search"));
+    }
+
+    public void testBoolQueryWithMustNot() throws Exception {
+        SearchRequest request = createSearchRequest();
+        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery()
+            .must(QueryBuilders.termQuery("status", "active"))
+            .mustNot(QueryBuilders.termQuery("acl_group", "team-alpha"));
+        request.source().query(boolQuery);
+
+        AclRoutingSearchProcessor processor = new AclRoutingSearchProcessor(null, null, false, "acl_group", true);
+
+        SearchRequest result = processor.processRequest(request);
+
+        assertThat(result.routing(), notNullValue());
+    }
+
+    public void testEmptyTermsQuery() throws Exception {
+        SearchRequest request = createSearchRequest();
+        request.source().query(QueryBuilders.termsQuery("acl_group", new Object[] {}));
+
+        AclRoutingSearchProcessor processor = new AclRoutingSearchProcessor(null, null, false, "acl_group", true);
+
+        SearchRequest result = processor.processRequest(request);
+
+        assertThat(result.routing(), nullValue());
+    }
+
+    public void testHashingConsistency() throws Exception {
+        String aclValue = "team-production";
+
+        SearchRequest request1 = createSearchRequest();
+        request1.source().query(QueryBuilders.termQuery("acl_group", aclValue));
+
+        SearchRequest request2 = createSearchRequest();
+        request2.source().query(QueryBuilders.termQuery("acl_group", aclValue));
+
+        AclRoutingSearchProcessor processor = new AclRoutingSearchProcessor(null, null, false, "acl_group", true);
+
+        processor.processRequest(request1);
+        processor.processRequest(request2);
+
+        assertThat(request1.routing(), equalTo(request2.routing()));
+    }
+
     private SearchRequest createSearchRequest() {
         SearchRequest request = new SearchRequest();
         request.source(new SearchSourceBuilder());