add unit test for ExpiredResultsRemoverTests

Author: valeriy42

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/retention/WritableIndexExpander.java

@@ -18,6 +18,10 @@
 import java.util.Objects;
 import java.util.stream.Collectors;
 
+/**
+ * This class is used to expand index patterns and filter out read-only indices.
+ * It is used in the context of machine learning jobs retention to ensure that only writable indices are considered.
+ */
 public class WritableIndexExpander {
 
     private final ClusterService clusterService;

x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/retention/ExpiredAnnotationsRemoverTests.java

@@ -212,16 +212,7 @@ private ExpiredAnnotationsRemover createExpiredAnnotationsRemover(Iterator<Job>
             return null;
         }).when(executor).execute(any());
 
-        WritableIndexExpander writableIndexExpander = mock(WritableIndexExpander.class);
-        if (annotationIndexWritable) {
-            when(writableIndexExpander.getWritableIndices(AnnotationIndex.READ_ALIAS_NAME)).thenReturn(
-                new ArrayList<>(Collections.singletonList(AnnotationIndex.READ_ALIAS_NAME))
-            );
-        } else {
-            when(writableIndexExpander.getWritableIndices(AnnotationIndex.READ_ALIAS_NAME)).thenReturn(
-                new ArrayList<>(Collections.emptyList())
-            );
-        }
+        WritableIndexExpander writableIndexExpander = MockWritableIndexExpander.create(annotationIndexWritable);
         return new ExpiredAnnotationsRemover(
             originSettingClient,
             jobIterator,

x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/retention/ExpiredModelSnapshotsRemoverTests.java

@@ -35,14 +35,12 @@
 import org.elasticsearch.xpack.ml.test.MockOriginSettingClient;
 import org.elasticsearch.xpack.ml.test.SearchHitBuilder;
 import org.junit.Before;
-import org.mockito.ArgumentMatchers;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
@@ -60,7 +58,6 @@
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
@@ -330,7 +327,7 @@ private ExpiredModelSnapshotsRemover createExpiredModelSnapshotsRemover(Iterator
             return null;
         }).when(executor).execute(any());
 
-        WritableIndexExpander writableIndexExpander = mockWritableIndexExpander(isStateIndexWritable);
+        WritableIndexExpander writableIndexExpander = MockWritableIndexExpander.create(isStateIndexWritable);
 
         return new ExpiredModelSnapshotsRemover(
             originSettingClient,
@@ -343,30 +340,6 @@ private ExpiredModelSnapshotsRemover createExpiredModelSnapshotsRemover(Iterator
         );
     }
 
-    private static WritableIndexExpander mockWritableIndexExpander(boolean stateIndexWritable) {
-        WritableIndexExpander writableIndexExpander = mock(WritableIndexExpander.class);
-        if (stateIndexWritable) {
-            mockWhenIndicesAreWritable(writableIndexExpander);
-        } else {
-            mockWhenIndicesAreNotWritable(writableIndexExpander);
-        }
-        return writableIndexExpander;
-    }
-
-    private static void mockWhenIndicesAreNotWritable(WritableIndexExpander writableIndexExpander) {
-        when(writableIndexExpander.getWritableIndices(anyString()))
-            .thenReturn(new ArrayList<>());
-        when(writableIndexExpander.getWritableIndices(ArgumentMatchers.<Collection<String>>any()))
-            .thenReturn(new ArrayList<>());
-    }
-
-    private static void mockWhenIndicesAreWritable(WritableIndexExpander writableIndexExpander) {
-        when(writableIndexExpander.getWritableIndices(anyString()))
-            .thenAnswer(invocation -> List.of(invocation.getArgument(0)));
-        when(writableIndexExpander.getWritableIndices(ArgumentMatchers.<Collection<String>>any()))
-            .thenAnswer(invocation -> new ArrayList<>(invocation.getArgument(0)));
-    }
-
     private static ModelSnapshot createModelSnapshot(String jobId, String snapshotId, Date date) {
         return new ModelSnapshot.Builder(jobId).setSnapshotId(snapshotId).setTimestamp(date).build();
     }

x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/retention/ExpiredResultsRemoverTests.java

@@ -11,12 +11,9 @@
 import org.elasticsearch.action.search.TransportSearchAction;
 import org.elasticsearch.client.internal.Client;
 import org.elasticsearch.client.internal.OriginSettingClient;
-import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
-import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.index.reindex.BulkByScrollResponse;
 import org.elasticsearch.index.reindex.DeleteByQueryAction;
 import org.elasticsearch.index.reindex.DeleteByQueryRequest;
-import org.elasticsearch.indices.TestIndexNameExpressionResolver;
 import org.elasticsearch.tasks.TaskId;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.threadpool.ThreadPool;
@@ -54,8 +51,6 @@ public class ExpiredResultsRemoverTests extends ESTestCase {
     private OriginSettingClient originSettingClient;
     private List<DeleteByQueryRequest> capturedDeleteByQueryRequests;
     private ActionListener<Boolean> listener;
-    private ClusterService clusterService;
-    private IndexNameExpressionResolver indexNameExpressionResolver = TestIndexNameExpressionResolver.newInstance();
 
     @Before
     @SuppressWarnings("unchecked")
@@ -65,7 +60,6 @@ public void setUpTests() {
         client = mock(Client.class);
         originSettingClient = MockOriginSettingClient.mockOriginSettingClient(client, ClientHelper.ML_ORIGIN);
         listener = mock(ActionListener.class);
-        clusterService = mock(ClusterService.class);
         when(listener.delegateFailureAndWrap(any())).thenCallRealMethod();
     }
 
@@ -141,6 +135,22 @@ public void testRemove_GivenClientRequestsFailed() {
         verify(listener).onFailure(any());
     }
 
+    public void testRemove_GivenIndexNotWritable_ShouldHandleGracefully() {
+        givenBucket(new Bucket("id_not_important", new Date(), 60));
+
+        // Prepare one job with a retention policy
+        List<Job> jobs = Arrays.asList(
+            JobTests.buildJobBuilder("results-1").setResultsRetentionDays(10L).build(),
+            JobTests.buildJobBuilder("results-1").setResultsRetentionDays(20L).build()
+        );
+
+        createExpiredResultsRemover(jobs.iterator(), false).remove(1.0f, listener, () -> false);
+
+        // Assert: success callback invoked, no DBQ requests
+        verify(listener).onResponse(true);
+        assertThat(capturedDeleteByQueryRequests.size(), equalTo(0));
+    }
+
     @SuppressWarnings("unchecked")
     public void testCalcCutoffEpochMs() {
         String jobId = "calc-cutoff";
@@ -191,7 +201,13 @@ private void givenBucket(Bucket bucket) {
         }).when(client).execute(eq(TransportSearchAction.TYPE), any(), any());
     }
 
+
+
     private ExpiredResultsRemover createExpiredResultsRemover(Iterator<Job> jobIterator) {
+        return createExpiredResultsRemover(jobIterator, true);
+    }
+
+    private ExpiredResultsRemover createExpiredResultsRemover(Iterator<Job> jobIterator, boolean isResultsIndexWritable) {
         ThreadPool threadPool = mock(ThreadPool.class);
         ExecutorService executor = mock(ExecutorService.class);
 
@@ -203,11 +219,13 @@ private ExpiredResultsRemover createExpiredResultsRemover(Iterator<Job> jobItera
             return null;
         }).when(executor).execute(any());
 
+        WritableIndexExpander writableIndexExpander = MockWritableIndexExpander.create(isResultsIndexWritable);
+
         return new ExpiredResultsRemover(
             originSettingClient,
             jobIterator,
             new TaskId("test", 0L),
-            new WritableIndexExpander(clusterService, indexNameExpressionResolver),
+            writableIndexExpander,
             mock(AnomalyDetectionAuditor.class),
             threadPool
         );

x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/job/retention/MockWritableIndexExpander.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.ml.job.retention;
+
+import org.mockito.ArgumentMatchers;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class MockWritableIndexExpander {
+    public static WritableIndexExpander create(boolean stateIndexWritable) {
+        WritableIndexExpander writableIndexExpander = mock(WritableIndexExpander.class);
+        if (stateIndexWritable) {
+            mockWhenIndicesAreWritable(writableIndexExpander);
+        } else {
+            mockWhenIndicesAreNotWritable(writableIndexExpander);
+        }
+        return writableIndexExpander;
+    }
+
+    private static void mockWhenIndicesAreNotWritable(WritableIndexExpander writableIndexExpander) {
+        when(writableIndexExpander.getWritableIndices(anyString()))
+            .thenReturn(new ArrayList<>());
+        when(writableIndexExpander.getWritableIndices(ArgumentMatchers.<Collection<String>>any()))
+            .thenReturn(new ArrayList<>());
+    }
+
+    private static void mockWhenIndicesAreWritable(WritableIndexExpander writableIndexExpander) {
+        when(writableIndexExpander.getWritableIndices(anyString())).thenAnswer(invocation -> {
+            String input = invocation.getArgument(0);
+            return new ArrayList<>(List.of(input));
+        });
+        when(writableIndexExpander.getWritableIndices(ArgumentMatchers.<Collection<String>>any())).thenAnswer(
+            invocation -> new ArrayList<>(invocation.getArgument(0))
+        );
+    }
+}