Add integration tests for min/max aggregations and fix javadocs

- Add testMinAggregation() and testMaxAggregation() to SearchServiceIT
- Verify min/max aggregations work end-to-end with live cluster via gRPC
- Add missing javadocs to AggregationBuilderProtoConverter* classes
- Add missing javadocs to AggregateProtoConverter* classes

Integration tests validate:
- Min aggregation returns correct minimum value (5.2 from [10.5, 25.0, 5.2])
- Max aggregation returns correct maximum value (25.0 from [10.5, 25.0, 5.2])
- gRPC aggregation results match expected values

All integration tests passing (8 tests total).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: Yiyu Pan <yypan14@gmail.com>

Author: yiyuabc

modules/transport-grpc/src/internalClusterTest/java/org/opensearch/transport/grpc/SearchServiceIT.java

@@ -8,6 +8,10 @@
 
 package org.opensearch.transport.grpc;
 
+import org.opensearch.protobufs.Aggregate;
+import org.opensearch.protobufs.AggregationContainer;
+import org.opensearch.protobufs.MaxAggregation;
+import org.opensearch.protobufs.MinAggregation;
 import org.opensearch.protobufs.SearchRequest;
 import org.opensearch.protobufs.SearchRequestBody;
 import org.opensearch.protobufs.SearchResponse;
@@ -57,4 +61,86 @@ public void testSearchServiceSearch() throws Exception {
             assertEquals("Hit should have correct ID", "1", searchResponse.getHits().getHits(0).getXId());
         }
     }
+
+    /**
+     * Tests min aggregation via gRPC.
+     */
+    public void testMinAggregation() throws Exception {
+        // Create a test index
+        String indexName = "test-min-agg";
+        createTestIndex(indexName);
+
+        // Index documents with different price values
+        indexTestDocument(indexName, "1", "{\"price\": 10.5}");
+        indexTestDocument(indexName, "2", "{\"price\": 25.0}");
+        indexTestDocument(indexName, "3", "{\"price\": 5.2}");
+
+        // Create a gRPC client
+        try (NettyGrpcClient client = createGrpcClient()) {
+            ManagedChannel channel = client.getChannel();
+            SearchServiceGrpc.SearchServiceBlockingStub searchStub = SearchServiceGrpc.newBlockingStub(channel);
+
+            // Build min aggregation request
+            MinAggregation minAgg = MinAggregation.newBuilder().setField("price").build();
+
+            SearchRequestBody requestBody = SearchRequestBody.newBuilder()
+                .setSize(0)
+                .putAggregations("min_price", AggregationContainer.newBuilder().setMin(minAgg).build())
+                .build();
+
+            SearchRequest searchRequest = SearchRequest.newBuilder().addIndex(indexName).setSearchRequestBody(requestBody).build();
+
+            // Execute search
+            SearchResponse response = searchStub.search(searchRequest);
+
+            // Verify min aggregation result
+            assertNotNull("Search response should not be null", response);
+            assertTrue("Should have aggregations", response.getAggregationsCount() > 0);
+            Aggregate minResult = response.getAggregationsMap().get("min_price");
+            assertNotNull("Min aggregation should exist", minResult);
+            assertTrue("Should have value", minResult.hasValue());
+            assertEquals("Min value should be 5.2", 5.2, minResult.getValue().getDouble(), 0.001);
+        }
+    }
+
+    /**
+     * Tests max aggregation via gRPC.
+     */
+    public void testMaxAggregation() throws Exception {
+        // Create a test index
+        String indexName = "test-max-agg";
+        createTestIndex(indexName);
+
+        // Index documents with different price values
+        indexTestDocument(indexName, "1", "{\"price\": 10.5}");
+        indexTestDocument(indexName, "2", "{\"price\": 25.0}");
+        indexTestDocument(indexName, "3", "{\"price\": 5.2}");
+
+        // Create a gRPC client
+        try (NettyGrpcClient client = createGrpcClient()) {
+            ManagedChannel channel = client.getChannel();
+            SearchServiceGrpc.SearchServiceBlockingStub searchStub = SearchServiceGrpc.newBlockingStub(channel);
+
+            // Build max aggregation request
+            MaxAggregation maxAgg = MaxAggregation.newBuilder().setField("price").build();
+
+            SearchRequestBody requestBody = SearchRequestBody.newBuilder()
+                .setSize(0)
+                .putAggregations("max_price", AggregationContainer.newBuilder().setMax(maxAgg).build())
+                .build();
+
+            SearchRequest searchRequest = SearchRequest.newBuilder().addIndex(indexName).setSearchRequestBody(requestBody).build();
+
+            // Execute search
+            SearchResponse response = searchStub.search(searchRequest);
+
+            // Verify max aggregation result
+            assertNotNull("Search response should not be null", response);
+            assertTrue("Should have aggregations", response.getAggregationsCount() > 0);
+            Aggregate maxResult = response.getAggregationsMap().get("max_price");
+            assertNotNull("Max aggregation should exist", maxResult);
+            assertTrue("Should have value", maxResult.hasValue());
+            assertEquals("Max value should be 25.0", 25.0, maxResult.getValue().getDouble(), 0.001);
+        }
+    }
 }

modules/transport-grpc/src/main/java/org/opensearch/transport/grpc/proto/request/search/aggregation/AggregationBuilderProtoConverterRegistryImpl.java

@@ -27,13 +27,19 @@ public class AggregationBuilderProtoConverterRegistryImpl implements Aggregation
     private static final Logger logger = LogManager.getLogger(AggregationBuilderProtoConverterRegistryImpl.class);
     private final AggregationBuilderProtoConverterSpiRegistry delegate;
 
+    /**
+     * Creates a new AggregationBuilderProtoConverterRegistryImpl and registers built-in converters.
+     */
     @Inject
     public AggregationBuilderProtoConverterRegistryImpl() {
         this.delegate = new AggregationBuilderProtoConverterSpiRegistry();
 
         registerBuiltInConverters();
     }
 
+    /**
+     * Registers all built-in aggregation converters.
+     */
     protected void registerBuiltInConverters() {
         // Register metric aggregation converters
         delegate.registerConverter(new MinAggregationBuilderProtoConverter());
@@ -51,16 +57,28 @@ protected void registerBuiltInConverters() {
     /**
      * Converts protobuf to AggregationBuilder.
      * Mirrors {@link org.opensearch.search.aggregations.AggregatorFactories#parseAggregators}.
+     *
+     * @param name The aggregation name
+     * @param container The protobuf container
+     * @return The OpenSearch AggregationBuilder
      */
     @Override
     public AggregationBuilder fromProto(String name, AggregationContainer container) {
         return delegate.fromProto(name, container);
     }
 
+    /**
+     * Registers an external aggregation converter.
+     *
+     * @param converter The converter to register
+     */
     public void registerConverter(AggregationBuilderProtoConverter converter) {
         delegate.registerConverter(converter);
     }
 
+    /**
+     * Updates the registry reference on all registered converters.
+     */
     public void updateRegistryOnAllConverters() {
         delegate.setRegistryOnAllConverters(this);
     }

modules/transport-grpc/src/main/java/org/opensearch/transport/grpc/proto/request/search/aggregation/AggregationBuilderProtoConverterSpiRegistry.java

@@ -32,6 +32,11 @@ public class AggregationBuilderProtoConverterSpiRegistry implements AggregationB
     private static final Logger logger = LogManager.getLogger(AggregationBuilderProtoConverterSpiRegistry.class);
     private final Map<AggregationContainer.AggregationContainerCase, AggregationBuilderProtoConverter> converterMap = new HashMap<>();
 
+    /**
+     * Creates a new AggregationBuilderProtoConverterSpiRegistry.
+     * External converters are loaded via OpenSearch's ExtensiblePlugin mechanism
+     * and registered manually via registerConverter() calls.
+     */
     @Inject
     public AggregationBuilderProtoConverterSpiRegistry() {
         // External converters are loaded via OpenSearch's ExtensiblePlugin mechanism
@@ -41,6 +46,10 @@ public AggregationBuilderProtoConverterSpiRegistry() {
     /**
      * Converts protobuf to AggregationBuilder with metadata and subaggregations.
      * Mirrors {@link org.opensearch.search.aggregations.AggregatorFactories#parseAggregators}.
+     *
+     * @param name The aggregation name
+     * @param container The protobuf container
+     * @return The OpenSearch AggregationBuilder
      */
     @Override
     public AggregationBuilder fromProto(String name, AggregationContainer container) {
@@ -98,17 +107,32 @@ public AggregationBuilder fromProto(String name, AggregationContainer container)
         return builder;
     }
 
+    /**
+     * Returns the number of registered converters.
+     *
+     * @return The converter count
+     */
     public int size() {
         return converterMap.size();
     }
 
+    /**
+     * Sets the registry on all registered converters.
+     *
+     * @param registry The registry to set
+     */
     public void setRegistryOnAllConverters(AggregationBuilderProtoConverterRegistry registry) {
         for (AggregationBuilderProtoConverter converter : converterMap.values()) {
             converter.setRegistry(registry);
         }
         logger.info("Set registry on {} aggregation converter(s)", converterMap.size());
     }
 
+    /**
+     * Registers a converter for a specific aggregation type.
+     *
+     * @param converter The converter to register
+     */
     public void registerConverter(AggregationBuilderProtoConverter converter) {
         if (converter == null) {
             throw new IllegalArgumentException("Converter cannot be null");

modules/transport-grpc/src/main/java/org/opensearch/transport/grpc/proto/response/search/aggregation/AggregateProtoConverterRegistryImpl.java

@@ -23,6 +23,9 @@ public class AggregateProtoConverterRegistryImpl implements AggregateProtoConver
 
     private final AggregateProtoConverterSpiRegistry spiRegistry;
 
+    /**
+     * Creates a new AggregateProtoConverterRegistryImpl and registers built-in converters.
+     */
     public AggregateProtoConverterRegistryImpl() {
         this.spiRegistry = new AggregateProtoConverterSpiRegistry();
         registerBuiltInConverters();

modules/transport-grpc/src/main/java/org/opensearch/transport/grpc/proto/response/search/aggregation/AggregateProtoConverterSpiRegistry.java

@@ -30,6 +30,11 @@ public class AggregateProtoConverterSpiRegistry implements AggregateProtoConvert
     private static final Logger logger = LogManager.getLogger(AggregateProtoConverterSpiRegistry.class);
     private final Map<Class<? extends InternalAggregation>, AggregateProtoConverter> converters = new HashMap<>();
 
+    /**
+     * Creates a new AggregateProtoConverterSpiRegistry.
+     * External converters can be loaded via OpenSearch's ExtensiblePlugin mechanism
+     * and registered manually via registerConverter() calls.
+     */
     public AggregateProtoConverterSpiRegistry() {
         // External converters can be loaded via OpenSearch's ExtensiblePlugin mechanism
         // and registered manually via registerConverter() calls

modules/transport-grpc/src/main/java/org/opensearch/transport/grpc/proto/response/search/aggregation/metrics/MaxAggregateProtoConverter.java

@@ -20,6 +20,11 @@
  */
 public class MaxAggregateProtoConverter implements AggregateProtoConverter {
 
+    /**
+     * Creates a new MaxAggregateProtoConverter.
+     */
+    public MaxAggregateProtoConverter() {}
+
     @Override
     public Class<? extends InternalAggregation> getHandledAggregationType() {
         return InternalMax.class;

modules/transport-grpc/src/main/java/org/opensearch/transport/grpc/proto/response/search/aggregation/metrics/MinAggregateProtoConverter.java

@@ -20,6 +20,11 @@
  */
 public class MinAggregateProtoConverter implements AggregateProtoConverter {
 
+    /**
+     * Creates a new MinAggregateProtoConverter.
+     */
+    public MinAggregateProtoConverter() {}
+
     @Override
     public Class<? extends InternalAggregation> getHandledAggregationType() {
         return InternalMin.class;