Adding test in phases

Author: Samiul-TheSoccerFan

x-pack/plugin/inference/src/internalClusterTest/java/org/elasticsearch/xpack/inference/integration/SemanticTextIndexVersionIT.java

@@ -7,32 +7,49 @@
 
 package org.elasticsearch.xpack.inference.integration;
 
-import org.elasticsearch.Version;
+import org.elasticsearch.action.DocWriteResponse;
+import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
+import org.elasticsearch.action.search.SearchRequest;
+import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.core.TimeValue;
-import org.elasticsearch.index.Index;
 import org.elasticsearch.index.IndexVersion;
 import org.elasticsearch.index.IndexVersions;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.license.LicenseSettings;
+import org.elasticsearch.plugins.Plugin;
+import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.elasticsearch.test.ESIntegTestCase;
-import org.elasticsearch.test.VersionUtils;
 import org.elasticsearch.test.index.IndexVersionUtils;
+import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xcontent.XContentFactory;
+import org.elasticsearch.xpack.inference.LocalStateInferencePlugin;
+import org.elasticsearch.xpack.inference.Utils;
+import org.elasticsearch.xpack.inference.mock.TestSparseInferenceServiceExtension;
+import org.elasticsearch.xpack.inference.queries.SemanticQueryBuilder;
 import org.junit.Before;
 
 import java.io.IOException;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
+import static org.hamcrest.Matchers.equalTo;
+
 public class SemanticTextIndexVersionIT extends ESIntegTestCase {
     private static final IndexVersion SEMANTIC_TEXT_INTRODUCED_VERSION = IndexVersions.SEMANTIC_TEXT_FIELD_TYPE;
+    private static final IndexVersion SEMANTIC_TEXT_NEW_FORMAT = IndexVersions.INFERENCE_METADATA_FIELDS_BACKPORT;
 
     private Set<IndexVersion> availableVersions;
     private static final int MIN_NUMBER_OF_TESTS_TO_RUN = 10;
 
     @Before
-    public void setupVersions() {
+    public void setup() throws Exception {
+        Utils.storeSparseModel(client());
         availableVersions = IndexVersionUtils.allReleasedVersions().stream()
             .filter((version -> version.onOrAfter(SEMANTIC_TEXT_INTRODUCED_VERSION)))
             .collect(Collectors.toSet());
@@ -45,18 +62,18 @@ protected boolean forbidPrivateIndexSettings() {
         return false;
     }
 
-//    /**
-//     * Creates an index with a random version from the filtered versions list.
-//     * @param indexName The name of the index to create
-//     * @return The selected version
-//     */
-//    protected Version createRandomVersionIndex(String indexName) throws IOException {
-//        Version indexVersion = randomFrom(availableVersions);
-//        logger.info("Creating index [{}] with version [{}]", indexName, indexVersion);
-//
-//        createIndex(indexName, getIndexSettingsWithVersion(indexVersion));
-//        return indexVersion;
-//    }
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal, Settings otherSettings) {
+        return Settings.builder()
+            .put(otherSettings)
+            .put(LicenseSettings.SELF_GENERATED_LICENSE_TYPE.getKey(), "trial")
+            .build();
+    }
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return List.of(LocalStateInferencePlugin.class);
+    }
 
     /**
      * Generate settings for an index with a specific version.
@@ -93,16 +110,77 @@ public void test() throws Exception {
         for (String indexName : indices.keySet()) {
             IndexVersion version = indices.get(indexName);
             logger.info("Testing index [{}] with version [{}]", indexName, version);
+
+            // Test index creation
             assertTrue("Index " + indexName + " should exist", indexExists(indexName));
             assertEquals("Index version should match",
                 version.id(),
                 client().admin().indices().prepareGetSettings(TimeValue.THIRTY_SECONDS, indexName)
                     .get().getIndexToSettings().get(indexName)
                     .getAsVersionId("index.version.created", IndexVersion::fromId).id());
+
+            // Test update mapping
+            XContentBuilder mapping = XContentFactory.jsonBuilder()
+                .startObject()
+                .startObject("properties")
+                .startObject("semantic_field")
+                .field("type", "semantic_text")
+                .field("inference_id", TestSparseInferenceServiceExtension.TestInferenceService.NAME)
+                .endObject()
+                .endObject()
+                .endObject();
+
+            assertAcked(client().admin().indices().preparePutMapping(indexName)
+                .setSource(mapping)
+                .get());
+
+            // Test data ingestion
+            String[] text = new String[] {"inference test", "another inference test"};
+
+            DocWriteResponse response = client().prepareIndex(indexName).setSource(Map.of("semantic_field", text)).get();
+
+            assertEquals("Document should be created", "created", response.getResult().toString().toLowerCase());
+
+            client().admin().indices().refresh(new RefreshRequest(indexName)).get();
+
+
+            // Simple search
+            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder().trackTotalHits(true);
+            SearchResponse searchResponse = client().search(new SearchRequest(indexName).source(sourceBuilder)).get();
+            try {
+                assertThat(searchResponse.getHits().getTotalHits().value(), equalTo(1L));
+            } finally {
+                searchResponse.decRef();
+            }
+
+            // Search with query
+            SearchResponse searchWithQueryResponse = null;
+            if (version.after(SEMANTIC_TEXT_NEW_FORMAT)) {
+                searchWithQueryResponse = client().search(new SearchRequest(indexName)
+                        .source(sourceBuilder.query(QueryBuilders.matchQuery("semantic_field", "another inference test"))))
+                    .get();
+            } else {
+                String semanticQuery = """
+                {
+                  "semantic": {
+                    "field": "semantic_field",
+                    "query": "inference"
+                  }
+                }
+                """;
+                searchWithQueryResponse = client().search(new SearchRequest(indexName)
+                        .source(sourceBuilder.query(new SemanticQueryBuilder("semantic_field", "inference test"))))
+                    .get();
+            }
+
+            try {
+                assertThat(searchResponse.getHits().getTotalHits().value(), equalTo(1L));
+            } finally {
+                searchResponse.decRef();
+            }
+
+
         }
     }
 
 }
-
-//[8.15.3, 8.17.3, 8.15.2, 8.16.6, 8.17.2, 9.0.0, 8.15.1, 8.16.5, 8.17.1, 8.15.0, 8.16.4, 8.17.0, 8.19.0, 8.16.3, 8.16.2, 9.1.0, 8.15.5, 8.16.1, 8.15.4, 8.16.0, 8.17.4, 8.18.0]
-// Available versions for testing: [8512000, 9005000, 9013000, 8520000, 8509000, 8517000, 9000000, 9008000, 8525000, 8514000, 9007000, 9015000, 8522000, 8511000, 8519000, 9002000, 9010000, 8527000, 8508000, 8516000, 9001000, 9009000, 8524000, 8513000, 9004000, 9012000, 8521000, 8510000, 8518000, 9003000, 9011000, 8526000, 8507000, 8515000, 9006000, 9014000, 8523000]