From fd0cdde38c93f72b4605b1f3e85a2ab1adce72a3 Mon Sep 17 00:00:00 2001 From: Aleksandr Maus Date: Fri, 20 Mar 2020 17:28:15 -0400 Subject: [PATCH] EQL: EqlActionIT improvements (#53780) (#53888) Related to https://github.com/elastic/elasticsearch/issues/53598 --- x-pack/plugin/eql/build.gradle | 20 +- x-pack/plugin/eql/qa/common/build.gradle | 5 + .../qa/common/licenses/jtoml-2.0.0.jar.sha1 | 1 + .../eql/qa/common/licenses/jtoml-LICENSE | 202 ++++++++++++++++++ .../eql/qa/common/licenses/jtoml-NOTICE | 0 .../test/eql/CommonEqlActionTestCase.java} | 107 +++++++--- .../org/elasticsearch/test/eql}/EqlSpec.java | 2 +- .../test/eql}/EqlSpecLoader.java | 2 +- .../common/src/main}/resources/test_data.json | 0 .../src/main}/resources/test_queries.toml | 0 .../resources/test_queries_unsupported.toml | 0 .../elasticsearch/xpack/eql/EqlActionIT.java | 17 ++ .../eql/action/AbstractEqlIntegTestCase.java | 46 ---- .../eql/action/LocalStateEqlXPackPlugin.java | 28 --- 14 files changed, 310 insertions(+), 120 deletions(-) create mode 100644 x-pack/plugin/eql/qa/common/licenses/jtoml-2.0.0.jar.sha1 create mode 100644 x-pack/plugin/eql/qa/common/licenses/jtoml-LICENSE create mode 100644 x-pack/plugin/eql/qa/common/licenses/jtoml-NOTICE rename x-pack/plugin/eql/{src/test/java/org/elasticsearch/xpack/eql/action/EqlActionIT.java => qa/common/src/main/java/org/elasticsearch/test/eql/CommonEqlActionTestCase.java} (54%) rename x-pack/plugin/eql/{src/test/java/org/elasticsearch/xpack/eql/action => qa/common/src/main/java/org/elasticsearch/test/eql}/EqlSpec.java (97%) rename x-pack/plugin/eql/{src/test/java/org/elasticsearch/xpack/eql/action => qa/common/src/main/java/org/elasticsearch/test/eql}/EqlSpecLoader.java (98%) rename x-pack/plugin/eql/{src/test => qa/common/src/main}/resources/test_data.json (100%) rename x-pack/plugin/eql/{src/test => qa/common/src/main}/resources/test_queries.toml (100%) rename x-pack/plugin/eql/{src/test => qa/common/src/main}/resources/test_queries_unsupported.toml (100%) create mode 100644 x-pack/plugin/eql/qa/rest/src/test/java/org/elasticsearch/xpack/eql/EqlActionIT.java delete mode 100644 x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/AbstractEqlIntegTestCase.java delete mode 100644 x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/LocalStateEqlXPackPlugin.java diff --git a/x-pack/plugin/eql/build.gradle b/x-pack/plugin/eql/build.gradle index 528139f34cf..13b12a0d887 100644 --- a/x-pack/plugin/eql/build.gradle +++ b/x-pack/plugin/eql/build.gradle @@ -20,15 +20,6 @@ archivesBaseName = 'x-pack-eql' // All integration tests live in qa modules integTest.enabled = false -// Instead we create a separate task to run the tests based on ESIntegTestCase -task internalClusterTest(type: Test) { - mustRunAfter test - include '**/*IT.class' - systemProperty 'es.set.netty.runtime.available.processors', 'false' -} - -check.dependsOn internalClusterTest - dependencies { compileOnly project(path: xpackModule('core'), configuration: 'default') compileOnly(project(':modules:lang-painless')) { @@ -43,15 +34,6 @@ dependencies { testCompile project(path: ':modules:reindex', configuration: 'runtime') testCompile project(path: ':modules:parent-join', configuration: 'runtime') testCompile project(path: ':modules:analysis-common', configuration: 'runtime') - - // TOML parser for EqlActionIT tests - testCompile 'io.ous:jtoml:2.0.0' - - // JSON parser for tests input data - testCompile "com.fasterxml.jackson.core:jackson-core:${versions.jackson}" - testCompile "com.fasterxml.jackson.core:jackson-annotations:${versions.jackson}" - testCompile "com.fasterxml.jackson.core:jackson-databind:${versions.jackson}" - } @@ -137,4 +119,4 @@ task regen { patternset(includes: 'EqlBase*.java') } } -} \ No newline at end of file +} diff --git a/x-pack/plugin/eql/qa/common/build.gradle b/x-pack/plugin/eql/qa/common/build.gradle index e1c6fb4f95b..6d980017391 100644 --- a/x-pack/plugin/eql/qa/common/build.gradle +++ b/x-pack/plugin/eql/qa/common/build.gradle @@ -3,4 +3,9 @@ test.enabled = false dependencies { compile project(':test:framework') + compile project(path: xpackModule('core'), configuration: 'default') + compile project(path: xpackModule('core'), configuration: 'testArtifacts') + + // TOML parser for EqlActionIT tests + compile 'io.ous:jtoml:2.0.0' } diff --git a/x-pack/plugin/eql/qa/common/licenses/jtoml-2.0.0.jar.sha1 b/x-pack/plugin/eql/qa/common/licenses/jtoml-2.0.0.jar.sha1 new file mode 100644 index 00000000000..ccf73fed50e --- /dev/null +++ b/x-pack/plugin/eql/qa/common/licenses/jtoml-2.0.0.jar.sha1 @@ -0,0 +1 @@ +2085505b2b173e14b2a7702edd703ce185fd6206 diff --git a/x-pack/plugin/eql/qa/common/licenses/jtoml-LICENSE b/x-pack/plugin/eql/qa/common/licenses/jtoml-LICENSE new file mode 100644 index 00000000000..d6456956733 --- /dev/null +++ b/x-pack/plugin/eql/qa/common/licenses/jtoml-LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/x-pack/plugin/eql/qa/common/licenses/jtoml-NOTICE b/x-pack/plugin/eql/qa/common/licenses/jtoml-NOTICE new file mode 100644 index 00000000000..e69de29bb2d diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlActionIT.java b/x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/CommonEqlActionTestCase.java similarity index 54% rename from x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlActionIT.java rename to x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/CommonEqlActionTestCase.java index cf313acd1a1..8e42d605234 100644 --- a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlActionIT.java +++ b/x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/CommonEqlActionTestCase.java @@ -4,31 +4,39 @@ * you may not use this file except in compliance with the Elastic License. */ -package org.elasticsearch.xpack.eql.action; +package org.elasticsearch.test.eql; import com.carrotsearch.randomizedtesting.annotations.ParametersFactory; -import com.fasterxml.jackson.databind.ObjectMapper; import org.elasticsearch.Build; -import org.elasticsearch.action.bulk.BulkRequestBuilder; +import org.elasticsearch.action.bulk.BulkRequest; import org.elasticsearch.action.bulk.BulkResponse; import org.elasticsearch.action.index.IndexRequest; import org.elasticsearch.action.support.WriteRequest; +import org.elasticsearch.client.RequestOptions; +import org.elasticsearch.client.RestHighLevelClient; +import org.elasticsearch.client.eql.EqlSearchRequest; +import org.elasticsearch.client.eql.EqlSearchResponse; +import org.elasticsearch.common.Strings; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.common.xcontent.json.JsonXContent; +import org.elasticsearch.rest.RestStatus; import org.elasticsearch.search.SearchHit; +import org.elasticsearch.test.rest.ESRestTestCase; import org.junit.After; import org.junit.Before; import org.junit.BeforeClass; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; import java.util.List; -import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.instanceOf; -public class EqlActionIT extends AbstractEqlIntegTestCase { +public abstract class CommonEqlActionTestCase extends ESRestTestCase { + + private RestHighLevelClient highLevelClient; static final String indexPrefix = "endgame"; static final String testIndexName = indexPrefix + "-1.4.0"; @@ -39,13 +47,20 @@ public class EqlActionIT extends AbstractEqlIntegTestCase { assumeTrue("Only works on snapshot builds for now", Build.CURRENT.isSnapshot()); } - @Before + private static boolean isSetUp = false; + private static int counter = 0; + @SuppressWarnings("unchecked") - public void setUpData() throws Exception { - // Insert test data - ObjectMapper mapper = new ObjectMapper(); - BulkRequestBuilder bulkBuilder = client().prepareBulk(); - try (XContentParser parser = createParser(JsonXContent.jsonXContent, EqlActionIT.class.getResourceAsStream("/test_data.json"))) { + private static void setupData(CommonEqlActionTestCase tc) throws Exception { + if (isSetUp) { + return; + } + + BulkRequest bulk = new BulkRequest(); + bulk.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE); + + try (XContentParser parser = tc.createParser(JsonXContent.jsonXContent, + CommonEqlActionTestCase.class.getResourceAsStream("/test_data.json"))) { List list = parser.list(); for (Object item : list) { assertThat(item, instanceOf(HashMap.class)); @@ -61,18 +76,40 @@ public class EqlActionIT extends AbstractEqlIntegTestCase { // Add @timestamp field entry.put("@timestamp", entry.get("timestamp")); - bulkBuilder.add(new IndexRequest(testIndexName).source(entry, XContentType.JSON)); + bulk.add(new IndexRequest(testIndexName).source(entry, XContentType.JSON)); } } - BulkResponse bulkResponse = bulkBuilder.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE).get(); - assertThat(bulkResponse.hasFailures() ? bulkResponse.buildFailureMessage() : "", bulkResponse.hasFailures(), equalTo(false)); - ensureYellow(testIndexName); + if (bulk.numberOfActions() > 0) { + BulkResponse bulkResponse = tc.highLevelClient().bulk(bulk, RequestOptions.DEFAULT); + assertEquals(RestStatus.OK, bulkResponse.status()); + assertFalse(bulkResponse.hasFailures()); + isSetUp = true; + } + } + + private static void cleanupData(CommonEqlActionTestCase tc) throws Exception { + // Delete index after all tests ran + if (isSetUp && (--counter == 0)) { + deleteIndex(testIndexName); + isSetUp = false; + } + } + + @Override + protected boolean preserveClusterUponCompletion() { + // Need to preserve data between parameterized tests runs + return true; + } + + @Before + public void setup() throws Exception { + setupData(this); } @After - public void tearDownData() { - client().admin().indices().prepareDelete(testIndexName).get(); + public void cleanup() throws Exception { + cleanupData(this); } @ParametersFactory(shuffle = false, argumentFormatting = PARAM_FORMATTING) @@ -84,7 +121,6 @@ public class EqlActionIT extends AbstractEqlIntegTestCase { List unsupportedSpecs = EqlSpecLoader.load("/test_queries_unsupported.toml", false); // Validate only currently supported specs - int num = 1; // Seq number of the test for (EqlSpec spec : specs) { boolean supported = true; // Check if spec is supported, simple iteration, cause the list is short. @@ -96,20 +132,36 @@ public class EqlActionIT extends AbstractEqlIntegTestCase { } if (supported) { - testSpecs.add(new Object[]{num++, spec}); + String name = spec.description(); + if (Strings.isNullOrEmpty(name)) { + name = spec.note(); + } + if (Strings.isNullOrEmpty(name)) { + name = spec.query(); + } + + testSpecs.add(new Object[]{++counter, name, spec}); } } return testSpecs; } private final int num; + private final String name; private final EqlSpec spec; - public EqlActionIT(int num, EqlSpec spec) { + public CommonEqlActionTestCase(int num, String name, EqlSpec spec) { this.num = num; + this.name = name; this.spec = spec; } + public void test() throws Exception { + EqlSearchRequest request = new EqlSearchRequest(testIndexName, spec.query()); + EqlSearchResponse response = highLevelClient().eql().search(request, RequestOptions.DEFAULT); + assertSpec(response.hits().events()); + } + private static long[] extractIds(List events) { final int len = events.size(); final long ids[] = new long[len]; @@ -124,10 +176,15 @@ public class EqlActionIT extends AbstractEqlIntegTestCase { assertArrayEquals("unexpected result for spec: [" + spec.toString() + "]", spec.expectedEventIds(), extractIds(events)); } - public final void test() { - EqlSearchResponse response = new EqlSearchRequestBuilder(client(), EqlSearchAction.INSTANCE) - .indices(testIndexName).query(spec.query()).get(); - - assertSpec(response.hits().events()); + private RestHighLevelClient highLevelClient() { + if (highLevelClient == null) { + highLevelClient = new RestHighLevelClient( + client(), + ignore -> { + }, + Collections.emptyList()) { + }; + } + return highLevelClient; } } diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlSpec.java b/x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/EqlSpec.java similarity index 97% rename from x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlSpec.java rename to x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/EqlSpec.java index 1db8269656f..00ebde23eed 100644 --- a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlSpec.java +++ b/x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/EqlSpec.java @@ -4,7 +4,7 @@ * you may not use this file except in compliance with the Elastic License. */ -package org.elasticsearch.xpack.eql.action; +package org.elasticsearch.test.eql; import org.elasticsearch.common.Strings; diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlSpecLoader.java b/x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/EqlSpecLoader.java similarity index 98% rename from x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlSpecLoader.java rename to x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/EqlSpecLoader.java index f5fe4f93c31..932874bc091 100644 --- a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/EqlSpecLoader.java +++ b/x-pack/plugin/eql/qa/common/src/main/java/org/elasticsearch/test/eql/EqlSpecLoader.java @@ -4,7 +4,7 @@ * you may not use this file except in compliance with the Elastic License. */ -package org.elasticsearch.xpack.eql.action; +package org.elasticsearch.test.eql; import io.ous.jtoml.JToml; import io.ous.jtoml.Toml; diff --git a/x-pack/plugin/eql/src/test/resources/test_data.json b/x-pack/plugin/eql/qa/common/src/main/resources/test_data.json similarity index 100% rename from x-pack/plugin/eql/src/test/resources/test_data.json rename to x-pack/plugin/eql/qa/common/src/main/resources/test_data.json diff --git a/x-pack/plugin/eql/src/test/resources/test_queries.toml b/x-pack/plugin/eql/qa/common/src/main/resources/test_queries.toml similarity index 100% rename from x-pack/plugin/eql/src/test/resources/test_queries.toml rename to x-pack/plugin/eql/qa/common/src/main/resources/test_queries.toml diff --git a/x-pack/plugin/eql/src/test/resources/test_queries_unsupported.toml b/x-pack/plugin/eql/qa/common/src/main/resources/test_queries_unsupported.toml similarity index 100% rename from x-pack/plugin/eql/src/test/resources/test_queries_unsupported.toml rename to x-pack/plugin/eql/qa/common/src/main/resources/test_queries_unsupported.toml diff --git a/x-pack/plugin/eql/qa/rest/src/test/java/org/elasticsearch/xpack/eql/EqlActionIT.java b/x-pack/plugin/eql/qa/rest/src/test/java/org/elasticsearch/xpack/eql/EqlActionIT.java new file mode 100644 index 00000000000..c69cd956790 --- /dev/null +++ b/x-pack/plugin/eql/qa/rest/src/test/java/org/elasticsearch/xpack/eql/EqlActionIT.java @@ -0,0 +1,17 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ + +package org.elasticsearch.xpack.eql; + +import org.elasticsearch.test.eql.CommonEqlActionTestCase; +import org.elasticsearch.test.eql.EqlSpec; + +public class EqlActionIT extends CommonEqlActionTestCase { + // Constructor for parameterized test + public EqlActionIT(int num, String name, EqlSpec spec) { + super(num, name, spec); + } +} diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/AbstractEqlIntegTestCase.java b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/AbstractEqlIntegTestCase.java deleted file mode 100644 index 2c8ba1acc64..00000000000 --- a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/AbstractEqlIntegTestCase.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License; - * you may not use this file except in compliance with the Elastic License. - */ -package org.elasticsearch.xpack.eql.action; - -import org.elasticsearch.common.settings.Settings; -import org.elasticsearch.license.LicenseService; -import org.elasticsearch.plugins.Plugin; -import org.elasticsearch.test.ESIntegTestCase; -import org.elasticsearch.xpack.core.XPackSettings; -import org.elasticsearch.xpack.eql.plugin.EqlPlugin; - -import java.util.Collection; -import java.util.Collections; - -import static org.elasticsearch.test.ESIntegTestCase.Scope.SUITE; - -@ESIntegTestCase.ClusterScope(scope = SUITE, numDataNodes = 0, numClientNodes = 0, maxNumDataNodes = 0, transportClientRatio = 0) -public abstract class AbstractEqlIntegTestCase extends ESIntegTestCase { - - @Override - protected Settings nodeSettings(int nodeOrdinal) { - Settings.Builder settings = Settings.builder().put(super.nodeSettings(nodeOrdinal)); - settings.put(XPackSettings.SECURITY_ENABLED.getKey(), false); - settings.put(XPackSettings.MONITORING_ENABLED.getKey(), false); - settings.put(XPackSettings.WATCHER_ENABLED.getKey(), false); - settings.put(XPackSettings.GRAPH_ENABLED.getKey(), false); - settings.put(XPackSettings.MACHINE_LEARNING_ENABLED.getKey(), false); - settings.put(EqlPlugin.EQL_ENABLED_SETTING.getKey(), true); - settings.put(LicenseService.SELF_GENERATED_LICENSE_TYPE.getKey(), "trial"); - return settings.build(); - } - - @Override - protected Collection> nodePlugins() { - return Collections.singletonList(LocalStateEqlXPackPlugin.class); - } - - @Override - protected Collection> transportClientPlugins() { - return nodePlugins(); - } -} - diff --git a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/LocalStateEqlXPackPlugin.java b/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/LocalStateEqlXPackPlugin.java deleted file mode 100644 index 7a6cd355a6f..00000000000 --- a/x-pack/plugin/eql/src/test/java/org/elasticsearch/xpack/eql/action/LocalStateEqlXPackPlugin.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one - * or more contributor license agreements. Licensed under the Elastic License; - * you may not use this file except in compliance with the Elastic License. - */ - -package org.elasticsearch.xpack.eql.action; - -import org.elasticsearch.common.settings.Settings; -import org.elasticsearch.license.XPackLicenseState; -import org.elasticsearch.xpack.core.LocalStateCompositeXPackPlugin; -import org.elasticsearch.xpack.eql.plugin.EqlPlugin; - -import java.nio.file.Path; - -public class LocalStateEqlXPackPlugin extends LocalStateCompositeXPackPlugin { - - public LocalStateEqlXPackPlugin(final Settings settings, final Path configPath) throws Exception { - super(settings, configPath); - LocalStateEqlXPackPlugin thisVar = this; - plugins.add(new EqlPlugin(settings) { - @Override - protected XPackLicenseState getLicenseState() { - return thisVar.getLicenseState(); - } - }); - } -}