added tests

Signed-off-by: Kai Huang <[email protected]>

Author: ahkcs

legacy/src/main/java/org/opensearch/sql/legacy/executor/join/ElasticJoinExecutor.java

@@ -52,19 +52,19 @@ public abstract class ElasticJoinExecutor extends ElasticHitsExecutor {
   private final Set<String> aliasesOnReturn;
   private final boolean allFieldsReturn;
   protected final String[] indices;
-  protected final JoinRequestBuilder requestBuilder;
+  protected final JoinRequestBuilder requestBuilder; // ✅ Added to store request builder
 
   protected ElasticJoinExecutor(Client client, JoinRequestBuilder requestBuilder) {
     metaResults = new MetaSearchResult();
     aliasesOnReturn = new HashSet<>();
     List<Field> firstTableReturnedField = requestBuilder.getFirstTable().getReturnedFields();
     List<Field> secondTableReturnedField = requestBuilder.getSecondTable().getReturnedFields();
     allFieldsReturn =
-        (firstTableReturnedField == null || firstTableReturnedField.size() == 0)
-            && (secondTableReturnedField == null || secondTableReturnedField.size() == 0);
+            (firstTableReturnedField == null || firstTableReturnedField.size() == 0)
+                    && (secondTableReturnedField == null || secondTableReturnedField.size() == 0);
     indices = getIndices(requestBuilder);
     this.client = client;
-    this.requestBuilder = requestBuilder;
+    this.requestBuilder = requestBuilder; // ✅ Store request builder for hint access
   }
 
   public void sendResponse(RestChannel channel) throws IOException {
@@ -86,15 +86,16 @@ public void sendResponse(RestChannel channel) throws IOException {
       throw e;
     }
     LOG.debug(
-        "[MCB] Successfully send response with size of {}. Thread id = {}",
-        len,
-        Thread.currentThread().getId());
+            "[MCB] Successfully send response with size of {}. Thread id = {}",
+            len,
+            Thread.currentThread().getId());
   }
 
   public void run() throws IOException, SqlParseException {
     try {
       long timeBefore = System.currentTimeMillis();
 
+      // ✅ Extract JOIN_TIME_OUT hint and create PIT with custom keepalive
       TimeValue customKeepAlive = extractJoinTimeoutFromHints();
       pit = customKeepAlive != null
               ? new PointInTimeHandlerImpl(client, indices, customKeepAlive)
@@ -175,8 +176,10 @@ TimeValue findJoinTimeoutInHints(List<Hint> hints) {
         Object[] params = hint.getParams();
         if (params != null && params.length > 0) {
           Integer timeoutSeconds = (Integer) params[0];
-          LOG.info("Found JOIN_TIME_OUT hint: {} seconds, applying to PIT keepalive", timeoutSeconds);
-          return TimeValue.timeValueSeconds(timeoutSeconds);
+          if (timeoutSeconds != null) {
+            LOG.info("Found JOIN_TIME_OUT hint: {} seconds, applying to PIT keepalive", timeoutSeconds);
+            return TimeValue.timeValueSeconds(timeoutSeconds);
+          }
         }
       }
     }

legacy/src/test/java/org/opensearch/sql/legacy/executor/join/ElasticJoinExecutorTest.java

@@ -6,79 +6,69 @@
 package org.opensearch.sql.legacy.executor.join;
 
 import static org.junit.Assert.*;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import lombok.SneakyThrows;
 import org.junit.Before;
 import org.junit.Test;
-import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.MockitoAnnotations;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.search.SearchHit;
+import org.opensearch.sql.legacy.domain.Field;
 import org.opensearch.sql.legacy.domain.Select;
 import org.opensearch.sql.legacy.domain.hints.Hint;
 import org.opensearch.sql.legacy.domain.hints.HintType;
-import org.opensearch.sql.legacy.pit.PointInTimeHandlerImpl;
 import org.opensearch.sql.legacy.query.join.JoinRequestBuilder;
 import org.opensearch.sql.legacy.query.join.TableInJoinRequestBuilder;
 import org.opensearch.transport.client.Client;
 
-@RunWith(MockitoJUnitRunner.class)
 public class ElasticJoinExecutorTest {
 
-    @Mock
-    private Client mockClient;
-
-    @Mock
-    private JoinRequestBuilder mockJoinRequestBuilder;
-
-    @Mock
-    private TableInJoinRequestBuilder mockFirstTable;
-
-    @Mock
-    private TableInJoinRequestBuilder mockSecondTable;
-
-    @Mock
-    private Select mockFirstSelect;
-
-    @Mock
-    private Select mockSecondSelect;
+    @Mock private Client mockClient;
+    @Mock private JoinRequestBuilder mockJoinRequestBuilder;
+    @Mock private TableInJoinRequestBuilder mockFirstTable;
+    @Mock private TableInJoinRequestBuilder mockSecondTable;
+    @Mock private Select mockFirstSelect;
+    @Mock private Select mockSecondSelect;
 
     private TestableElasticJoinExecutor executor;
 
-    // Concrete test implementation to access private methods
+    // Concrete test implementation to access private methods and test behavior
     private static class TestableElasticJoinExecutor extends ElasticJoinExecutor {
 
         public TestableElasticJoinExecutor(Client client, JoinRequestBuilder requestBuilder) {
             super(client, requestBuilder);
         }
 
         @Override
-        protected List<org.opensearch.search.SearchHit> innerRun() {
+        protected List<SearchHit> innerRun() {
             return new ArrayList<>();
         }
 
         // Expose private methods for testing
         public TimeValue testExtractJoinTimeoutFromHints() {
-            return super.extractJoinTimeoutFromHints();
+            return extractJoinTimeoutFromHints();
         }
 
         public TimeValue testGetJoinTimeoutFromTable(TableInJoinRequestBuilder table) {
-            return super.getJoinTimeoutFromTable(table);
+            return getJoinTimeoutFromTable(table);
         }
 
         public TimeValue testFindJoinTimeoutInHints(List<Hint> hints) {
-            return super.findJoinTimeoutInHints(hints);
+            return findJoinTimeoutInHints(hints);
         }
     }
 
     @Before
     public void setUp() {
-        // Setup mock chain
+        MockitoAnnotations.initMocks(this);
+
+        // Setup mock chain for constructor requirements
         when(mockJoinRequestBuilder.getFirstTable()).thenReturn(mockFirstTable);
         when(mockJoinRequestBuilder.getSecondTable()).thenReturn(mockSecondTable);
         when(mockFirstTable.getOriginalSelect()).thenReturn(mockFirstSelect);
@@ -284,7 +274,7 @@ public void testExtractJoinTimeoutFromHints_ExceptionHandling() {
 
     @Test
     public void testBoundaryValues() {
-        // Test various timeout values
+        // Test various timeout values that might be used in real scenarios
         int[] testValues = {1, 30, 60, 90, 300, 3600, 7200}; // 1s to 2hrs
 
         for (int timeoutSeconds : testValues) {
@@ -301,6 +291,39 @@ public void testBoundaryValues() {
         }
     }
 
+    @Test
+    public void testTypicalJoinTimeoutScenarios() {
+        // Test common JOIN_TIME_OUT scenarios
+        int[] commonTimeouts = {90, 180, 300, 600}; // 1.5min, 3min, 5min, 10min
+
+        for (int timeout : commonTimeouts) {
+            // Arrange
+            List<Hint> hints = createJoinTimeoutHints(timeout);
+            when(mockFirstSelect.getHints()).thenReturn(hints);
+            when(mockSecondSelect.getHints()).thenReturn(new ArrayList<>());
+
+            // Act
+            TimeValue result = executor.testExtractJoinTimeoutFromHints();
+
+            // Assert
+            assertNotNull("Should extract JOIN_TIME_OUT(" + timeout + ")", result);
+            assertEquals("Should extract " + timeout + " seconds", timeout, result.getSeconds());
+        }
+    }
+
+    @Test
+    public void testConstructorStoresRequestBuilder() {
+        // Verify that the constructor properly stores the request builder for hint access
+        assertNotNull("Executor should be created successfully", executor);
+
+        // Test that the executor can access hints through the stored request builder
+        List<Hint> hints = createJoinTimeoutHints(90);
+        when(mockFirstSelect.getHints()).thenReturn(hints);
+
+        TimeValue result = executor.testExtractJoinTimeoutFromHints();
+        assertNotNull("Should be able to access hints through stored request builder", result);
+    }
+
     // Helper Methods
 
     private List<Hint> createJoinTimeoutHints(int timeoutSeconds) {