Add unit tests

(cherry picked from commit ca06254a)

search-core/src/test/java/org/opengroup/osdu/search/service/IndexAliasServiceImplTest.java

+package org.opengroup.osdu.search.service;
+
+
+import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
+import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
+import org.elasticsearch.action.support.master.AcknowledgedResponse;
+import org.elasticsearch.client.*;
+import org.elasticsearch.cluster.metadata.AliasMetadata;
+import org.elasticsearch.rest.RestStatus;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opengroup.osdu.core.common.logging.JaxRsDpsLog;
+import org.opengroup.osdu.core.common.search.ElasticIndexNameResolver;
+import org.opengroup.osdu.search.util.ElasticClientHandler;
+import org.powermock.api.mockito.PowerMockito;
+import org.springframework.context.annotation.Lazy;
+
+import java.io.IOException;
+import java.util.*;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+@RunWith(MockitoJUnitRunner.class)
+public class IndexAliasServiceImplTest {
+    @Mock
+    private ElasticClientHandler elasticClientHandler;
+    @Mock
+    private ElasticIndexNameResolver elasticIndexNameResolver;
+    @Mock
+    @Lazy
+    private JaxRsDpsLog log;
+    @InjectMocks
+    private IndexAliasServiceImpl sut;
+
+    private RestHighLevelClient restHighLevelClient;
+    private IndicesClient indicesClient;
+    private GetAliasesResponse getAliasesResponse;
+
+    private static String kind = "common:welldb:wellbore:1.2.0";
+    private static String index = "common-welldb-wellbore-1.2.0";
+    private static String alias = "a1234567890";
+
+    @Before
+    public void setup() {
+        initMocks(this);
+        indicesClient = PowerMockito.mock(IndicesClient.class);
+        restHighLevelClient = PowerMockito.mock(RestHighLevelClient.class);
+        getAliasesResponse = PowerMockito.mock(GetAliasesResponse.class);
+    }
+
+    @Test
+    public void getInDicesAliases_when_kind_is_not_supported_for_alias() throws IOException {
+        when(elasticIndexNameResolver.isIndexAliasSupported(any())).thenReturn(false);
+        List<String> kinds = Arrays.asList(kind);
+        Map<String, String> kindAliasMap = sut.getIndicesAliases(kinds);
+        assertTrue(kindAliasMap.isEmpty());
+    }
+
+    @Test
+    public void getInDicesAliases_when_alias_exist() throws IOException {
+        setup_when_alias_exist();
+
+        List<String> kinds = Arrays.asList(kind);
+        Map<String, String> kindAliasMap = sut.getIndicesAliases(kinds);
+        verify(this.indicesClient, times(1)).getAlias(any(), any());
+        assertTrue(kindAliasMap.containsKey(kind));
+        assertEquals(alias, kindAliasMap.get(kind));
+    }
+
+    @Test
+    public void getInDicesAliases_when_alias_exist_with_cache_take_effect() throws IOException {
+        setup_when_alias_exist();
+
+        List<String> kinds = Arrays.asList(kind);
+        Map<String, String> kindAliasMap = sut.getIndicesAliases(kinds);
+        verify(this.indicesClient, times(1)).getAlias(any(), any());
+        assertTrue(kindAliasMap.containsKey(kind));
+        assertEquals(alias, kindAliasMap.get(kind));
+
+        // call again. It should get from cache
+        sut.getIndicesAliases(kinds);
+        verify(this.indicesClient, times(1)).getAlias(any(), any());
+    }
+
+    @Test
+    public void getInDicesAliases_when_alias_not_exist_and_create_alias_successfully() throws IOException {
+        setup_when_alias_not_exist_and_try_create_alias(true);
+
+        List<String> kinds = Arrays.asList(kind);
+        Map<String, String> kindAliasMap = sut.getIndicesAliases(kinds);
+        assertTrue(kindAliasMap.containsKey(kind));
+        assertEquals(alias, kindAliasMap.get(kind));
+    }
+
+    @Test
+    public void getInDicesAliases_when_alias_not_exist_and_fail_create_alias() throws IOException {
+        setup_when_alias_not_exist_and_try_create_alias(false);
+
+        List<String> kinds = Arrays.asList(kind);
+        Map<String, String> kindAliasMap = sut.getIndicesAliases(kinds);
+        assertTrue(kindAliasMap.isEmpty());
+    }
+
+    private void setup_when_alias_exist() throws IOException {
+        Map<String, Set<AliasMetadata>> aliases = new HashMap<>();
+        Set<AliasMetadata> aliasMetadataSet = new HashSet<>();
+        aliasMetadataSet.add(AliasMetadata.builder(alias).build());
+        aliases.put(index, aliasMetadataSet);
+
+        when(elasticIndexNameResolver.getIndexAliasFromKind(any())).thenReturn(alias);
+        when(elasticIndexNameResolver.isIndexAliasSupported(any())).thenReturn(true);
+        when(elasticClientHandler.createRestClient()).thenReturn(restHighLevelClient);
+        when(restHighLevelClient.indices()).thenReturn(indicesClient);
+        when(indicesClient.getAlias(any(GetAliasesRequest.class), any(RequestOptions.class))).thenReturn(getAliasesResponse);
+        when(getAliasesResponse.status()).thenReturn(RestStatus.OK);
+        when(getAliasesResponse.getAliases()).thenReturn(aliases);
+    }
+
+    private void setup_when_alias_not_exist_and_try_create_alias(boolean create_ok) throws IOException {
+        GetAliasesResponse getAliasesResponseWithAliasConstraint = PowerMockito.mock(GetAliasesResponse.class);
+        Map<String, Set<AliasMetadata>> aliases = new HashMap<>();
+        Set<AliasMetadata> aliasMetadataSet = new HashSet<>();
+        aliasMetadataSet.add(AliasMetadata.builder("otherAlias").build());
+        aliases.put("otherIndex", aliasMetadataSet);
+        AcknowledgedResponse updateAliasesResponse = new AcknowledgedResponse(create_ok);
+        when(elasticIndexNameResolver.getIndexNameFromKind(any())).thenReturn(index);
+        when(elasticIndexNameResolver.getIndexAliasFromKind(any())).thenReturn(alias);
+        when(elasticIndexNameResolver.isIndexAliasSupported(any())).thenReturn(true);
+        when(elasticClientHandler.createRestClient()).thenReturn(restHighLevelClient);
+        when(restHighLevelClient.indices()).thenReturn(indicesClient);
+        when(indicesClient.getAlias(any(GetAliasesRequest.class), any(RequestOptions.class)))
+                .thenAnswer(invocation ->
+                {
+                    GetAliasesRequest request = invocation.getArgument(0);
+                    if(request.aliases().length == 0)
+                        return getAliasesResponse;
+                    else
+                        return getAliasesResponseWithAliasConstraint;
+                });
+        when(getAliasesResponse.status()).thenReturn(RestStatus.OK);
+        when(getAliasesResponse.getAliases()).thenReturn(aliases);
+        when(getAliasesResponseWithAliasConstraint.status()).thenReturn(RestStatus.NOT_FOUND);
+        when(indicesClient.updateAliases(any(IndicesAliasesRequest.class), any(RequestOptions.class))).thenReturn(updateAliasesResponse);
+    }
+}

search-core/src/test/java/org/opengroup/osdu/search/util/CrossTenantUtilsTest.java

@@ -22,20 +22,28 @@ import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.opengroup.osdu.core.common.model.search.QueryRequest;
 import org.opengroup.osdu.core.common.search.ElasticIndexNameResolver;
+import org.opengroup.osdu.search.service.IndexAliasService;
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
 public class CrossTenantUtilsTest {
+    private static final int MAX_INDEX_NAME_LENGTH = 3840;
 
     @Mock
     private QueryRequest queryRequest;
     @Mock
     private ElasticIndexNameResolver elasticIndexNameResolver;
+    @Mock
+    private IndexAliasService indexAliasService;
     @InjectMocks
     private CrossTenantUtils sut;
 
@@ -79,4 +87,87 @@ public class CrossTenantUtilsTest {
         });
         assertEquals(indices, this.sut.getIndexName(queryRequest));
     }
+
+    @Test
+    public void should_returnMultiIndicesAsIs_when_total_length_is_not_longer_than_max_length() {
+        List<String> kinds = getKindsNotLongerThan(MAX_INDEX_NAME_LENGTH);
+        when(queryRequest.getKind()).thenReturn(kinds);
+        when(this.elasticIndexNameResolver.getIndexNameFromKind(anyString())).thenAnswer(invocation ->
+        {
+            String kd = invocation.getArgument(0);
+            kd = kd.replace(":", "-");
+            return kd;
+        });
+        assertEquals(getIndexName(kinds), this.sut.getIndexName(queryRequest));
+    }
+
+    @Test
+    public void should_returnMultiIndices_aliases_when_total_length_is_longer_than_max_length() {
+        List<String> kinds = getKindsNotLongerThan(MAX_INDEX_NAME_LENGTH * 2);
+        String alias = "a1234567890";
+        Map<String, String> kindAliasMap = new HashMap<>();
+        kindAliasMap.put(kinds.get(0), alias);
+
+        when(indexAliasService.getIndicesAliases(any())).thenReturn(kindAliasMap);
+        when(queryRequest.getKind()).thenReturn(kinds);
+        when(this.elasticIndexNameResolver.getIndexNameFromKind(anyString())).thenAnswer(invocation ->
+        {
+            String kd = invocation.getArgument(0);
+            kd = kd.replace(":", "-");
+            return kd;
+        });
+        assertEquals(getIndexName(kinds.size(), alias), this.sut.getIndexName(queryRequest));
+    }
+
+    @Test
+    public void should_returnMultiIndicesAsIs_when_total_length_is_longer_than_max_length_but_alias_exist() {
+        List<String> kinds = getKindsNotLongerThan(MAX_INDEX_NAME_LENGTH * 2);
+        Map<String, String> kindAliasMap = new HashMap<>();
+
+        when(indexAliasService.getIndicesAliases(any())).thenReturn(kindAliasMap);
+        when(queryRequest.getKind()).thenReturn(kinds);
+        when(this.elasticIndexNameResolver.getIndexNameFromKind(anyString())).thenAnswer(invocation ->
+        {
+            String kd = invocation.getArgument(0);
+            kd = kd.replace(":", "-");
+            return kd;
+        });
+        assertEquals(getIndexName(kinds), this.sut.getIndexName(queryRequest));
+    }
+
+    private List<String> getKindsNotLongerThan(int length) {
+        String kind = "osdu:wks:master-data-wellbore:1.0.0";
+        ArrayList kinds = new ArrayList();
+        int lengthPerKind = kind.length() + 1; // 1 is comma
+        int totalLength = "-.*".length();
+        int n = 0;
+        while (totalLength + lengthPerKind<= length) {
+            kinds.add(kind);
+            totalLength += lengthPerKind;
+        }
+        return kinds;
+    }
+
+    private String getIndexName(int numberOfAlias, String alias) {
+        StringBuilder builder = new StringBuilder();
+        int n = 0;
+        while(n < numberOfAlias) {
+            builder.append(alias);
+            builder.append(",");
+            n++;
+        }
+        builder.append("-.*");
+        return builder.toString();
+    }
+
+    private String getIndexName(List<String> kinds) {
+        StringBuilder builder = new StringBuilder();
+        for(String kind : kinds) {
+            String index = kind.replace(":", "-");
+            builder.append(index);
+            builder.append(",");
+        }
+        builder.append("-.*");
+        return builder.toString();
+    }
 }