diff --git a/core/src/main/java/org/elasticsearch/common/ParseField.java b/core/src/main/java/org/elasticsearch/common/ParseField.java index 7121be7d1d880..fc9377eeb2f20 100644 --- a/core/src/main/java/org/elasticsearch/common/ParseField.java +++ b/core/src/main/java/org/elasticsearch/common/ParseField.java @@ -101,14 +101,10 @@ public ParseField withAllDeprecated(String allReplacedWith) { /** * @param fieldName * the field name to match against this {@link ParseField} - * @param strict - * if true an exception will be thrown if a deprecated field name - * is given. If false the deprecated name will be matched but a - * message will also be logged to the {@link DeprecationLogger} * @return true if fieldName matches any of the acceptable * names for this {@link ParseField}. */ - boolean match(String fieldName, boolean strict) { + public boolean match(String fieldName) { Objects.requireNonNull(fieldName, "fieldName cannot be null"); // if this parse field has not been completely deprecated then try to // match the preferred name @@ -128,11 +124,7 @@ boolean match(String fieldName, boolean strict) { // message to indicate what should be used instead msg = "Deprecated field [" + fieldName + "] used, replaced by [" + allReplacedWith + "]"; } - if (strict) { - throw new IllegalArgumentException(msg); - } else { - DEPRECATION_LOGGER.deprecated(msg); - } + DEPRECATION_LOGGER.deprecated(msg); return true; } } diff --git a/core/src/main/java/org/elasticsearch/common/ParseFieldMatcher.java b/core/src/main/java/org/elasticsearch/common/ParseFieldMatcher.java index 9866694a230ef..a7d412398e5b7 100644 --- a/core/src/main/java/org/elasticsearch/common/ParseFieldMatcher.java +++ b/core/src/main/java/org/elasticsearch/common/ParseFieldMatcher.java @@ -22,38 +22,29 @@ import org.elasticsearch.common.settings.Settings; /** - * Matcher to use in combination with {@link ParseField} while parsing requests. Matches a {@link ParseField} - * against a field name and throw deprecation exception depending on the current value of the {@link #PARSE_STRICT} setting. + * Matcher to use in combination with {@link ParseField} while parsing requests. + * + * @deprecated This class used to be useful to parse in strict mode and emit errors rather than deprecation warnings. Now that we return + * warnings as response headers all the time, it is no longer useful and will soon be removed. The removal is in progress and there is + * already no strict mode in fact. Use {@link ParseField} directly. */ +@Deprecated public class ParseFieldMatcher { - public static final String PARSE_STRICT = "index.query.parse.strict"; - public static final ParseFieldMatcher EMPTY = new ParseFieldMatcher(false); - public static final ParseFieldMatcher STRICT = new ParseFieldMatcher(true); - - private final boolean strict; + public static final ParseFieldMatcher EMPTY = new ParseFieldMatcher(Settings.EMPTY); + public static final ParseFieldMatcher STRICT = new ParseFieldMatcher(Settings.EMPTY); public ParseFieldMatcher(Settings settings) { - this(settings.getAsBoolean(PARSE_STRICT, false)); - } - - public ParseFieldMatcher(boolean strict) { - this.strict = strict; - } - - /** Should deprecated settings be rejected? */ - public boolean isStrict() { - return strict; + //we don't do anything with the settings argument, this whole class will be soon removed } /** - * Matches a {@link ParseField} against a field name, and throws deprecation exception depending on the current - * value of the {@link #PARSE_STRICT} setting. + * Matches a {@link ParseField} against a field name, * @param fieldName the field name found in the request while parsing * @param parseField the parse field that we are looking for * @throws IllegalArgumentException whenever we are in strict mode and the request contained a deprecated field * @return true whenever the parse field that we are looking for was found, false otherwise */ public boolean match(String fieldName, ParseField parseField) { - return parseField.match(fieldName, strict); + return parseField.match(fieldName); } } diff --git a/core/src/main/java/org/elasticsearch/common/logging/DeprecationLogger.java b/core/src/main/java/org/elasticsearch/common/logging/DeprecationLogger.java index ace0569a14a4e..55f89ce84ad5f 100644 --- a/core/src/main/java/org/elasticsearch/common/logging/DeprecationLogger.java +++ b/core/src/main/java/org/elasticsearch/common/logging/DeprecationLogger.java @@ -21,7 +21,6 @@ import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; -import org.apache.logging.log4j.message.ParameterizedMessage; import org.elasticsearch.common.SuppressLoggerChecks; import org.elasticsearch.common.util.concurrent.ThreadContext; @@ -42,7 +41,7 @@ public class DeprecationLogger { * * https://tools.ietf.org/html/rfc7234#section-5.5 */ - public static final String DEPRECATION_HEADER = "Warning"; + public static final String WARNING_HEADER = "Warning"; /** * This is set once by the {@code Node} constructor, but it uses {@link CopyOnWriteArraySet} to ensure that tests can run in parallel. @@ -128,7 +127,7 @@ void deprecated(Set threadContexts, String message, Object... par while (iterator.hasNext()) { try { - iterator.next().addResponseHeader(DEPRECATION_HEADER, formattedMessage); + iterator.next().addResponseHeader(WARNING_HEADER, formattedMessage); } catch (IllegalStateException e) { // ignored; it should be removed shortly } diff --git a/core/src/main/java/org/elasticsearch/index/mapper/TypeParsers.java b/core/src/main/java/org/elasticsearch/index/mapper/TypeParsers.java index 475848989d443..0eb21be486240 100644 --- a/core/src/main/java/org/elasticsearch/index/mapper/TypeParsers.java +++ b/core/src/main/java/org/elasticsearch/index/mapper/TypeParsers.java @@ -25,7 +25,6 @@ import org.elasticsearch.common.joda.FormatDateTimeFormatter; import org.elasticsearch.common.joda.Joda; import org.elasticsearch.common.logging.DeprecationLogger; -import org.elasticsearch.common.logging.ESLoggerFactory; import org.elasticsearch.common.logging.Loggers; import org.elasticsearch.common.xcontent.support.XContentMapValues; import org.elasticsearch.index.analysis.NamedAnalyzer; @@ -43,7 +42,6 @@ import static org.elasticsearch.common.xcontent.support.XContentMapValues.isArray; import static org.elasticsearch.common.xcontent.support.XContentMapValues.lenientNodeBooleanValue; import static org.elasticsearch.common.xcontent.support.XContentMapValues.nodeFloatValue; -import static org.elasticsearch.common.xcontent.support.XContentMapValues.nodeIntegerValue; import static org.elasticsearch.common.xcontent.support.XContentMapValues.nodeMapValue; import static org.elasticsearch.common.xcontent.support.XContentMapValues.nodeStringValue; @@ -59,16 +57,11 @@ public class TypeParsers { private static final Set BOOLEAN_STRINGS = new HashSet<>(Arrays.asList("true", "false")); public static boolean nodeBooleanValue(String name, Object node, Mapper.TypeParser.ParserContext parserContext) { - // Hook onto ParseFieldMatcher so that parsing becomes strict when setting index.query.parse.strict - if (parserContext.parseFieldMatcher().isStrict()) { - return XContentMapValues.nodeBooleanValue(node); - } else { - // TODO: remove this leniency in 6.0 - if (BOOLEAN_STRINGS.contains(node.toString()) == false) { - DEPRECATION_LOGGER.deprecated("Expected a boolean for property [{}] but got [{}]", name, node); - } - return XContentMapValues.lenientNodeBooleanValue(node); + // TODO: remove this leniency in 6.0 + if (BOOLEAN_STRINGS.contains(node.toString()) == false) { + DEPRECATION_LOGGER.deprecated("Expected a boolean for property [{}] but got [{}]", name, node); } + return XContentMapValues.lenientNodeBooleanValue(node); } private static void parseAnalyzersAndTermVectors(FieldMapper.Builder builder, String name, Map fieldNode, Mapper.TypeParser.ParserContext parserContext) { @@ -211,10 +204,10 @@ public static void parseField(FieldMapper.Builder builder, String name, Map private static final ParseField UNIT_FIELD = new ParseField("unit"); private static final ParseField DISTANCE_TYPE_FIELD = new ParseField("distance_type"); private static final ParseField VALIDATION_METHOD_FIELD = new ParseField("validation_method"); - private static final ParseField IGNORE_MALFORMED_FIELD = new ParseField("ignore_malformed") - .withAllDeprecated("use validation_method instead"); - private static final ParseField COERCE_FIELD = new ParseField("coerce", "normalize") - .withAllDeprecated("use validation_method instead"); + private static final ParseField IGNORE_MALFORMED_FIELD = new ParseField("ignore_malformed").withAllDeprecated("validation_method"); + private static final ParseField COERCE_FIELD = new ParseField("coerce", "normalize").withAllDeprecated("validation_method"); private static final ParseField SORTMODE_FIELD = new ParseField("mode", "sort_mode"); private final String fieldName; diff --git a/core/src/test/java/org/elasticsearch/action/admin/indices/template/BWCTemplateTests.java b/core/src/test/java/org/elasticsearch/action/admin/indices/template/BWCTemplateTests.java index 69c6731aa1537..7ea103313fe83 100644 --- a/core/src/test/java/org/elasticsearch/action/admin/indices/template/BWCTemplateTests.java +++ b/core/src/test/java/org/elasticsearch/action/admin/indices/template/BWCTemplateTests.java @@ -42,12 +42,14 @@ public void testBeatsTemplatesBWC() throws Exception { client().prepareIndex("packetbeat-foo", "doc", "1").setSource("message", "foo").get(); client().prepareIndex("filebeat-foo", "doc", "1").setSource("message", "foo").get(); client().prepareIndex("winlogbeat-foo", "doc", "1").setSource("message", "foo").get(); + assertWarnings("Deprecated field [template] used, replaced by [index_patterns]"); } public void testLogstashTemplatesBWC() throws Exception { String ls5x = copyToStringFromClasspath("/org/elasticsearch/action/admin/indices/template/logstash-5.0.template.json"); client().admin().indices().preparePutTemplate("logstash-5x").setSource(ls5x).get(); client().prepareIndex("logstash-foo", "doc", "1").setSource("message", "foo").get(); + assertWarnings("Deprecated field [template] used, replaced by [index_patterns]"); } } diff --git a/core/src/test/java/org/elasticsearch/common/ParseFieldTests.java b/core/src/test/java/org/elasticsearch/common/ParseFieldTests.java index 1f348000ee4cc..59b37f9e9e696 100644 --- a/core/src/test/java/org/elasticsearch/common/ParseFieldTests.java +++ b/core/src/test/java/org/elasticsearch/common/ParseFieldTests.java @@ -20,77 +20,45 @@ import org.elasticsearch.test.ESTestCase; -import static org.hamcrest.CoreMatchers.containsString; +import java.io.IOException; + import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.not; import static org.hamcrest.CoreMatchers.sameInstance; import static org.hamcrest.collection.IsArrayContainingInAnyOrder.arrayContainingInAnyOrder; public class ParseFieldTests extends ESTestCase { - public void testParse() { + public void testParse() throws IOException { String name = "foo_bar"; ParseField field = new ParseField(name); String[] deprecated = new String[]{"barFoo", "bar_foo", "Foobar"}; ParseField withDeprecations = field.withDeprecation(deprecated); assertThat(field, not(sameInstance(withDeprecations))); - assertThat(field.match(name, false), is(true)); - assertThat(field.match("foo bar", false), is(false)); - for (String deprecatedName : deprecated) { - assertThat(field.match(deprecatedName, false), is(false)); - } - - assertThat(withDeprecations.match(name, false), is(true)); - assertThat(withDeprecations.match("foo bar", false), is(false)); - for (String deprecatedName : deprecated) { - assertThat(withDeprecations.match(deprecatedName, false), is(true)); - } - - // now with strict mode - assertThat(field.match(name, true), is(true)); - assertThat(field.match("foo bar", true), is(false)); + assertThat(field.match(name), is(true)); + assertThat(field.match("foo bar"), is(false)); for (String deprecatedName : deprecated) { - assertThat(field.match(deprecatedName, true), is(false)); + assertThat(field.match(deprecatedName), is(false)); } - assertThat(withDeprecations.match(name, true), is(true)); - assertThat(withDeprecations.match("foo bar", true), is(false)); + assertThat(withDeprecations.match(name), is(true)); + assertThat(withDeprecations.match("foo bar"), is(false)); for (String deprecatedName : deprecated) { - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> { - withDeprecations.match(deprecatedName, true); - }); - assertThat(e.getMessage(), containsString("used, expected [foo_bar] instead")); + assertThat(withDeprecations.match(deprecatedName), is(true)); + assertWarnings("Deprecated field [" + deprecatedName + "] used, expected [foo_bar] instead"); } } - public void testAllDeprecated() { + public void testAllDeprecated() throws IOException { String name = "like_text"; - - boolean withDeprecatedNames = randomBoolean(); String[] deprecated = new String[]{"text", "same_as_text"}; - String[] allValues; - if (withDeprecatedNames) { - String[] newArray = new String[1 + deprecated.length]; - newArray[0] = name; - System.arraycopy(deprecated, 0, newArray, 1, deprecated.length); - allValues = newArray; - } else { - allValues = new String[] {name}; - } - - ParseField field; - if (withDeprecatedNames) { - field = new ParseField(name).withDeprecation(deprecated).withAllDeprecated("like"); - } else { - field = new ParseField(name).withAllDeprecated("like"); - } - - // strict mode off - assertThat(field.match(randomFrom(allValues), false), is(true)); - assertThat(field.match("not a field name", false), is(false)); - - // now with strict mode - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> field.match(randomFrom(allValues), true)); - assertThat(e.getMessage(), containsString(" used, replaced by [like]")); + ParseField field = new ParseField(name).withDeprecation(deprecated).withAllDeprecated("like"); + assertFalse(field.match("not a field name")); + assertTrue(field.match("text")); + assertWarnings("Deprecated field [text] used, replaced by [like]"); + assertTrue(field.match("same_as_text")); + assertWarnings("Deprecated field [same_as_text] used, replaced by [like]"); + assertTrue(field.match("like_text")); + assertWarnings("Deprecated field [like_text] used, replaced by [like]"); } public void testGetAllNamesIncludedDeprecated() { diff --git a/core/src/test/java/org/elasticsearch/common/logging/DeprecationLoggerTests.java b/core/src/test/java/org/elasticsearch/common/logging/DeprecationLoggerTests.java index f75e73ced2c8e..d0e1b807baf63 100644 --- a/core/src/test/java/org/elasticsearch/common/logging/DeprecationLoggerTests.java +++ b/core/src/test/java/org/elasticsearch/common/logging/DeprecationLoggerTests.java @@ -41,6 +41,12 @@ public class DeprecationLoggerTests extends ESTestCase { private final DeprecationLogger logger = new DeprecationLogger(Loggers.getLogger(getClass())); + @Override + protected boolean enableWarningsCheck() { + //this is a low level test for the deprecation logger, setup and checks are done manually + return false; + } + public void testAddsHeaderWithThreadContext() throws IOException { String msg = "A simple message [{}]"; String param = randomAsciiOfLengthBetween(1, 5); @@ -54,7 +60,7 @@ public void testAddsHeaderWithThreadContext() throws IOException { Map> responseHeaders = threadContext.getResponseHeaders(); assertEquals(1, responseHeaders.size()); - assertEquals(formatted, responseHeaders.get(DeprecationLogger.DEPRECATION_HEADER).get(0)); + assertEquals(formatted, responseHeaders.get(DeprecationLogger.WARNING_HEADER).get(0)); } } @@ -74,7 +80,7 @@ public void testAddsCombinedHeaderWithThreadContext() throws IOException { assertEquals(1, responseHeaders.size()); - List responses = responseHeaders.get(DeprecationLogger.DEPRECATION_HEADER); + List responses = responseHeaders.get(DeprecationLogger.WARNING_HEADER); assertEquals(2, responses.size()); assertEquals(formatted, responses.get(0)); @@ -93,7 +99,7 @@ public void testCanRemoveThreadContext() throws IOException { logger.deprecated(expected); Map> responseHeaders = threadContext.getResponseHeaders(); - List responses = responseHeaders.get(DeprecationLogger.DEPRECATION_HEADER); + List responses = responseHeaders.get(DeprecationLogger.WARNING_HEADER); // ensure it works (note: concurrent tests may be adding to it, but in different threads, so it should have no impact) assertThat(responses, hasSize(atLeast(1))); @@ -104,7 +110,7 @@ public void testCanRemoveThreadContext() throws IOException { logger.deprecated(unexpected); responseHeaders = threadContext.getResponseHeaders(); - responses = responseHeaders.get(DeprecationLogger.DEPRECATION_HEADER); + responses = responseHeaders.get(DeprecationLogger.WARNING_HEADER); assertThat(responses, hasSize(atLeast(1))); assertThat(responses, hasItem(expected)); diff --git a/core/src/test/java/org/elasticsearch/common/xcontent/ObjectParserTests.java b/core/src/test/java/org/elasticsearch/common/xcontent/ObjectParserTests.java index 46c0ba3572342..48860e008cdb0 100644 --- a/core/src/test/java/org/elasticsearch/common/xcontent/ObjectParserTests.java +++ b/core/src/test/java/org/elasticsearch/common/xcontent/ObjectParserTests.java @@ -218,27 +218,17 @@ public void setTest(int test) { } } - public void testDeprecationFail() throws IOException { - XContentParser parser = createParser(JsonXContent.jsonXContent, "{\"old_test\" : \"foo\"}"); + public void testDeprecationWarnings() throws IOException { class TestStruct { public String test; } ObjectParser objectParser = new ObjectParser<>("foo"); TestStruct s = new TestStruct(); - + XContentParser parser = createParser(XContentType.JSON.xContent(), "{\"old_test\" : \"foo\"}"); objectParser.declareField((i, v, c) -> v.test = i.text(), new ParseField("test", "old_test"), ObjectParser.ValueType.STRING); - - try { - objectParser.parse(parser, s, STRICT_PARSING); - fail("deprecated value"); - } catch (IllegalArgumentException ex) { - assertEquals(ex.getMessage(), "Deprecated field [old_test] used, expected [test] instead"); - - } - assertNull(s.test); - parser = createParser(JsonXContent.jsonXContent, "{\"old_test\" : \"foo\"}"); objectParser.parse(parser, s, () -> ParseFieldMatcher.EMPTY); assertEquals("foo", s.test); + assertWarnings("Deprecated field [old_test] used, expected [test] instead"); } public void testFailOnValueType() throws IOException { diff --git a/core/src/test/java/org/elasticsearch/index/analysis/AnalysisRegistryTests.java b/core/src/test/java/org/elasticsearch/index/analysis/AnalysisRegistryTests.java index 4a5a0b9567206..dedd478e3bfc8 100644 --- a/core/src/test/java/org/elasticsearch/index/analysis/AnalysisRegistryTests.java +++ b/core/src/test/java/org/elasticsearch/index/analysis/AnalysisRegistryTests.java @@ -104,7 +104,7 @@ public void testOverrideDefaultIndexAnalyzerIsUnsupported() { assertTrue(e.getMessage().contains("[index.analysis.analyzer.default_index] is not supported")); } - public void testBackCompatOverrideDefaultIndexAnalyzer() { + public void testBackCompatOverrideDefaultIndexAnalyzer() throws IOException { Version version = VersionUtils.randomVersionBetween(random(), VersionUtils.getFirstVersion(), VersionUtils.getPreviousVersion(Version.V_5_0_0_alpha1)); Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, version).build(); @@ -113,6 +113,8 @@ public void testBackCompatOverrideDefaultIndexAnalyzer() { assertThat(indexAnalyzers.getDefaultIndexAnalyzer().analyzer(), instanceOf(EnglishAnalyzer.class)); assertThat(indexAnalyzers.getDefaultSearchAnalyzer().analyzer(), instanceOf(StandardAnalyzer.class)); assertThat(indexAnalyzers.getDefaultSearchQuoteAnalyzer().analyzer(), instanceOf(StandardAnalyzer.class)); + assertWarnings("setting [index.analysis.analyzer.default_index] is deprecated, use [index.analysis.analyzer.default] " + + "instead for index [index]"); } public void testOverrideDefaultSearchAnalyzer() { @@ -125,7 +127,7 @@ public void testOverrideDefaultSearchAnalyzer() { assertThat(indexAnalyzers.getDefaultSearchQuoteAnalyzer().analyzer(), instanceOf(EnglishAnalyzer.class)); } - public void testBackCompatOverrideDefaultIndexAndSearchAnalyzer() { + public void testBackCompatOverrideDefaultIndexAndSearchAnalyzer() throws IOException { Version version = VersionUtils.randomVersionBetween(random(), VersionUtils.getFirstVersion(), VersionUtils.getPreviousVersion(Version.V_5_0_0_alpha1)); Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, version).build(); @@ -137,6 +139,8 @@ public void testBackCompatOverrideDefaultIndexAndSearchAnalyzer() { assertThat(indexAnalyzers.getDefaultIndexAnalyzer().analyzer(), instanceOf(EnglishAnalyzer.class)); assertThat(indexAnalyzers.getDefaultSearchAnalyzer().analyzer(), instanceOf(EnglishAnalyzer.class)); assertThat(indexAnalyzers.getDefaultSearchQuoteAnalyzer().analyzer(), instanceOf(EnglishAnalyzer.class)); + assertWarnings("setting [index.analysis.analyzer.default_index] is deprecated, use [index.analysis.analyzer.default] " + + "instead for index [index]"); } public void testConfigureCamelCaseTokenFilter() throws IOException { diff --git a/core/src/test/java/org/elasticsearch/index/mapper/DynamicTemplateTests.java b/core/src/test/java/org/elasticsearch/index/mapper/DynamicTemplateTests.java index f41b36068ad9f..24023281f5e7e 100644 --- a/core/src/test/java/org/elasticsearch/index/mapper/DynamicTemplateTests.java +++ b/core/src/test/java/org/elasticsearch/index/mapper/DynamicTemplateTests.java @@ -26,6 +26,7 @@ import org.elasticsearch.index.mapper.DynamicTemplate.XContentFieldType; import org.elasticsearch.test.ESTestCase; +import java.io.IOException; import java.util.Collections; import java.util.HashMap; import java.util.Map; @@ -43,7 +44,7 @@ public void testParseUnknownParam() throws Exception { assertEquals("Illegal dynamic template parameter: [random_param]", e.getMessage()); } - public void testParseUnknownMatchType() { + public void testParseUnknownMatchType() throws IOException { Map templateDef = new HashMap<>(); templateDef.put("match_mapping_type", "short"); templateDef.put("mapping", Collections.singletonMap("store", true)); diff --git a/core/src/test/java/org/elasticsearch/index/mapper/MapperServiceTests.java b/core/src/test/java/org/elasticsearch/index/mapper/MapperServiceTests.java index 42e880151693d..59bda1c877976 100644 --- a/core/src/test/java/org/elasticsearch/index/mapper/MapperServiceTests.java +++ b/core/src/test/java/org/elasticsearch/index/mapper/MapperServiceTests.java @@ -160,12 +160,13 @@ public void testMappingDepthExceedsLimit() throws Throwable { assertThat(e.getMessage(), containsString("Limit of mapping depth [1] in index [test1] has been exceeded")); } - public void testUnmappedFieldType() { + public void testUnmappedFieldType() throws IOException { MapperService mapperService = createIndex("index").mapperService(); assertThat(mapperService.unmappedFieldType("keyword"), instanceOf(KeywordFieldType.class)); assertThat(mapperService.unmappedFieldType("long"), instanceOf(NumberFieldType.class)); // back compat assertThat(mapperService.unmappedFieldType("string"), instanceOf(KeywordFieldType.class)); + assertWarnings("[unmapped_type:string] should be replaced with [unmapped_type:keyword]"); } public void testMergeWithMap() throws Throwable { @@ -206,9 +207,7 @@ public void testOtherDocumentMappersOnlyUpdatedWhenChangingFieldType() throws IO .startObject("properties") .startObject("field") .field("type", "text") - .startObject("norms") - .field("enabled", false) - .endObject() + .field("norms", false) .endObject() .endObject().endObject().bytes()); diff --git a/core/src/test/java/org/elasticsearch/index/query/GeoBoundingBoxQueryBuilderTests.java b/core/src/test/java/org/elasticsearch/index/query/GeoBoundingBoxQueryBuilderTests.java index 49266ebe9fd04..b2d1b957befcb 100644 --- a/core/src/test/java/org/elasticsearch/index/query/GeoBoundingBoxQueryBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/GeoBoundingBoxQueryBuilderTests.java @@ -19,13 +19,8 @@ package org.elasticsearch.index.query; -import org.apache.lucene.search.BooleanClause; -import org.apache.lucene.search.BooleanQuery; -import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.MatchNoDocsQuery; import org.apache.lucene.search.Query; -import org.apache.lucene.spatial.geopoint.search.GeoPointInBBoxQuery; -import org.elasticsearch.Version; import org.elasticsearch.common.geo.GeoPoint; import org.elasticsearch.common.geo.GeoUtils; import org.elasticsearch.index.mapper.MappedFieldType; @@ -40,7 +35,6 @@ import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.Matchers.equalTo; public class GeoBoundingBoxQueryBuilderTests extends AbstractQueryTestCase { /** Randomly generate either NaN or one of the two infinity values. */ @@ -118,7 +112,7 @@ public void testToQuery() throws IOException { public void testExceptionOnMissingTypes() throws IOException { assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length == 0); - QueryShardException e = expectThrows(QueryShardException.class, () -> super.testToQuery()); + QueryShardException e = expectThrows(QueryShardException.class, super::testToQuery); assertEquals("failed to find geo_point field [mapped_geo_point]", e.getMessage()); } @@ -412,7 +406,7 @@ public void testFromJson() throws IOException { assertEquals(json, GeoExecType.MEMORY, parsed.type()); } - public void testFromJsonCoerceFails() throws IOException { + public void testFromJsonCoerceIsDeprecated() throws IOException { String json = "{\n" + " \"geo_bounding_box\" : {\n" + @@ -426,11 +420,12 @@ public void testFromJsonCoerceFails() throws IOException { " \"boost\" : 1.0\n" + " }\n" + "}"; - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json)); - assertTrue(e.getMessage().startsWith("Deprecated field ")); + + parseQuery(json); + assertWarnings("Deprecated field [coerce] used, replaced by [validation_method]"); } - public void testFromJsonIgnoreMalformedFails() throws IOException { + public void testFromJsonIgnoreMalformedIsDeprecated() throws IOException { String json = "{\n" + " \"geo_bounding_box\" : {\n" + @@ -444,8 +439,8 @@ public void testFromJsonIgnoreMalformedFails() throws IOException { " \"boost\" : 1.0\n" + " }\n" + "}"; - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json)); - assertTrue(e.getMessage().startsWith("Deprecated field ")); + parseQuery(json); + assertWarnings("Deprecated field [ignore_malformed] used, replaced by [validation_method]"); } @Override diff --git a/core/src/test/java/org/elasticsearch/index/query/GeoDistanceQueryBuilderTests.java b/core/src/test/java/org/elasticsearch/index/query/GeoDistanceQueryBuilderTests.java index 6c92fde684315..dec1ee0a7df22 100644 --- a/core/src/test/java/org/elasticsearch/index/query/GeoDistanceQueryBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/GeoDistanceQueryBuilderTests.java @@ -316,7 +316,7 @@ public void testFromJson() throws IOException { assertEquals(json, 12000.0, parsed.distance(), 0.0001); } - public void testOptimizeBboxFails() throws IOException { + public void testOptimizeBboxIsDeprecated() throws IOException { String json = "{\n" + " \"geo_distance\" : {\n" + @@ -329,11 +329,12 @@ public void testOptimizeBboxFails() throws IOException { " \"boost\" : 1.0\n" + " }\n" + "}"; - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json)); - assertTrue(e.getMessage().startsWith("Deprecated field ")); + parseQuery(json); + assertWarnings("Deprecated field [optimize_bbox] used, replaced by [no replacement: " + + "`optimize_bbox` is no longer supported due to recent improvements]"); } - public void testFromCoerceFails() throws IOException { + public void testFromCoerceIsDeprecated() throws IOException { String json = "{\n" + " \"geo_distance\" : {\n" + @@ -345,11 +346,11 @@ public void testFromCoerceFails() throws IOException { " \"boost\" : 1.0\n" + " }\n" + "}"; - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json)); - assertTrue(e.getMessage().startsWith("Deprecated field ")); + parseQuery(json); + assertWarnings("Deprecated field [coerce] used, replaced by [validation_method]"); } - public void testFromJsonIgnoreMalformedFails() throws IOException { + public void testFromJsonIgnoreMalformedIsDeprecated() throws IOException { String json = "{\n" + " \"geo_distance\" : {\n" + @@ -361,8 +362,8 @@ public void testFromJsonIgnoreMalformedFails() throws IOException { " \"boost\" : 1.0\n" + " }\n" + "}"; - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json)); - assertTrue(e.getMessage().startsWith("Deprecated field ")); + parseQuery(json); + assertWarnings("Deprecated field [ignore_malformed] used, replaced by [validation_method]"); } @Override diff --git a/core/src/test/java/org/elasticsearch/index/query/GeoPolygonQueryBuilderTests.java b/core/src/test/java/org/elasticsearch/index/query/GeoPolygonQueryBuilderTests.java index b77ff3bbdef88..6df61d8cb451d 100644 --- a/core/src/test/java/org/elasticsearch/index/query/GeoPolygonQueryBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/GeoPolygonQueryBuilderTests.java @@ -139,8 +139,8 @@ public void testDeprecatedXContent() throws IOException { builder.field("normalize", true); // deprecated builder.endObject(); builder.endObject(); - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(builder.string())); - assertEquals("Deprecated field [normalize] used, replaced by [use validation_method instead]", e.getMessage()); + parseQuery(builder.string()); + assertWarnings("Deprecated field [normalize] used, replaced by [validation_method]"); } public void testParsingAndToQueryParsingExceptions() throws IOException { @@ -265,9 +265,8 @@ public void testFromJsonIgnoreMalformedDeprecated() throws IOException { " \"boost\" : 1.0\n" + " }\n" + "}"; - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json)); - assertTrue(e.getMessage().startsWith("Deprecated field ")); - + parseQuery(json); + assertWarnings("Deprecated field [ignore_malformed] used, replaced by [validation_method]"); } public void testFromJsonCoerceDeprecated() throws IOException { @@ -282,8 +281,8 @@ public void testFromJsonCoerceDeprecated() throws IOException { " \"boost\" : 1.0\n" + " }\n" + "}"; - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json)); - assertTrue(e.getMessage().startsWith("Deprecated field ")); + parseQuery(json); + assertWarnings("Deprecated field [coerce] used, replaced by [validation_method]"); } @Override diff --git a/core/src/test/java/org/elasticsearch/index/query/HasParentQueryBuilderTests.java b/core/src/test/java/org/elasticsearch/index/query/HasParentQueryBuilderTests.java index ca402782e8c50..cf4b0617ea98e 100644 --- a/core/src/test/java/org/elasticsearch/index/query/HasParentQueryBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/HasParentQueryBuilderTests.java @@ -23,7 +23,6 @@ import org.apache.lucene.search.Query; import org.apache.lucene.search.join.ScoreMode; import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest; -import org.elasticsearch.common.ParseFieldMatcher; import org.elasticsearch.common.compress.CompressedXContent; import org.elasticsearch.common.xcontent.ToXContent; import org.elasticsearch.common.xcontent.XContentBuilder; @@ -149,12 +148,9 @@ public void testDeprecatedXContent() throws IOException { builder.field("type", "foo"); // deprecated builder.endObject(); builder.endObject(); - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(builder.string())); - assertEquals("Deprecated field [type] used, expected [parent_type] instead", e.getMessage()); - - HasParentQueryBuilder queryBuilder = (HasParentQueryBuilder) parseQuery(builder.string(), ParseFieldMatcher.EMPTY); + HasParentQueryBuilder queryBuilder = (HasParentQueryBuilder) parseQuery(builder.string()); assertEquals("foo", queryBuilder.type()); - checkWarningHeaders("Deprecated field [type] used, expected [parent_type] instead"); + assertWarnings("Deprecated field [type] used, expected [parent_type] instead"); } public void testToQueryInnerQueryType() throws IOException { diff --git a/core/src/test/java/org/elasticsearch/index/query/IdsQueryBuilderTests.java b/core/src/test/java/org/elasticsearch/index/query/IdsQueryBuilderTests.java index 5913a03866155..de7762246ece3 100644 --- a/core/src/test/java/org/elasticsearch/index/query/IdsQueryBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/IdsQueryBuilderTests.java @@ -164,11 +164,8 @@ public void testFromJsonDeprecatedSyntax() throws IOException { IdsQueryBuilder parsed = (IdsQueryBuilder) parseQuery(contentString, ParseFieldMatcher.EMPTY); assertEquals(testQuery, parsed); - ParsingException e = expectThrows(ParsingException.class, () -> parseQuery(contentString)); - checkWarningHeaders("Deprecated field [_type] used, expected [type] instead"); - assertEquals("Deprecated field [_type] used, expected [type] instead", e.getMessage()); - assertEquals(3, e.getLineNumber()); - assertEquals(19, e.getColumnNumber()); + parseQuery(contentString); + assertWarnings("Deprecated field [_type] used, expected [type] instead"); //array of types can also be called types rather than type final String contentString2 = "{\n" + @@ -180,10 +177,7 @@ public void testFromJsonDeprecatedSyntax() throws IOException { parsed = (IdsQueryBuilder) parseQuery(contentString2, ParseFieldMatcher.EMPTY); assertEquals(testQuery, parsed); - e = expectThrows(ParsingException.class, () -> parseQuery(contentString2)); - checkWarningHeaders("Deprecated field [types] used, expected [type] instead"); - assertEquals("Deprecated field [types] used, expected [type] instead", e.getMessage()); - assertEquals(3, e.getLineNumber()); - assertEquals(19, e.getColumnNumber()); + parseQuery(contentString2); + assertWarnings("Deprecated field [types] used, expected [type] instead"); } } diff --git a/core/src/test/java/org/elasticsearch/index/query/MatchQueryBuilderTests.java b/core/src/test/java/org/elasticsearch/index/query/MatchQueryBuilderTests.java index a32eafd850c08..a5684863e51dd 100644 --- a/core/src/test/java/org/elasticsearch/index/query/MatchQueryBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/MatchQueryBuilderTests.java @@ -318,13 +318,8 @@ public void testLegacyMatchPhrasePrefixQuery() throws IOException { assertSerialization(qb); - checkWarningHeaders("Deprecated field [type] used, replaced by [match_phrase and match_phrase_prefix query]", + assertWarnings("Deprecated field [type] used, replaced by [match_phrase and match_phrase_prefix query]", "Deprecated field [slop] used, replaced by [match_phrase query]"); - - // Now check with strict parsing an exception is thrown - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json, ParseFieldMatcher.STRICT)); - assertThat(e.getMessage(), - containsString("Deprecated field [type] used, replaced by [match_phrase and match_phrase_prefix query]")); } public void testLegacyMatchPhraseQuery() throws IOException { @@ -351,16 +346,9 @@ public void testLegacyMatchPhraseQuery() throws IOException { checkGeneratedJson(json, qb); assertEquals(json, expectedQB, qb); - assertSerialization(qb); - - checkWarningHeaders("Deprecated field [type] used, replaced by [match_phrase and match_phrase_prefix query]", + assertWarnings("Deprecated field [type] used, replaced by [match_phrase and match_phrase_prefix query]", "Deprecated field [slop] used, replaced by [match_phrase query]"); - - // Now check with strict parsing an exception is thrown - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json, ParseFieldMatcher.STRICT)); - assertThat(e.getMessage(), - containsString("Deprecated field [type] used, replaced by [match_phrase and match_phrase_prefix query]")); } public void testFuzzinessOnNonStringField() throws Exception { diff --git a/core/src/test/java/org/elasticsearch/index/query/RangeQueryBuilderTests.java b/core/src/test/java/org/elasticsearch/index/query/RangeQueryBuilderTests.java index 09627d00d76d9..b48179e0a733a 100644 --- a/core/src/test/java/org/elasticsearch/index/query/RangeQueryBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/RangeQueryBuilderTests.java @@ -26,7 +26,6 @@ import org.apache.lucene.search.Query; import org.apache.lucene.search.TermRangeQuery; import org.elasticsearch.ElasticsearchParseException; -import org.elasticsearch.common.ParseFieldMatcher; import org.elasticsearch.common.ParsingException; import org.elasticsearch.common.geo.ShapeRelation; import org.elasticsearch.common.lucene.BytesRefs; @@ -39,7 +38,6 @@ import org.joda.time.DateTime; import org.joda.time.DateTimeZone; import org.joda.time.chrono.ISOChronology; -import org.locationtech.spatial4j.shape.SpatialRelation; import java.io.IOException; import java.util.HashMap; @@ -388,14 +386,8 @@ public void testNamedQueryParsing() throws IOException { " }\n" + "}"; - // non strict parsing should accept "_name" on top level - assertNotNull(parseQuery(json, ParseFieldMatcher.EMPTY)); - - // with strict parsing, ParseField will throw exception - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, - () -> parseQuery(deprecatedJson, ParseFieldMatcher.STRICT)); - assertEquals("Deprecated field [_name] used, replaced by [query name is not supported in short version of range query]", - e.getMessage()); + assertNotNull(parseQuery(deprecatedJson)); + assertWarnings("Deprecated field [_name] used, replaced by [query name is not supported in short version of range query]"); } public void testRewriteDateToMatchAll() throws IOException { diff --git a/core/src/test/java/org/elasticsearch/indices/analysis/AnalysisModuleTests.java b/core/src/test/java/org/elasticsearch/indices/analysis/AnalysisModuleTests.java index 6f379e48baefb..b568ae9276d43 100644 --- a/core/src/test/java/org/elasticsearch/indices/analysis/AnalysisModuleTests.java +++ b/core/src/test/java/org/elasticsearch/indices/analysis/AnalysisModuleTests.java @@ -136,6 +136,10 @@ public void testAnalyzerAlias() throws IOException { IndexAnalyzers indexAnalyzers = getIndexAnalyzers(newRegistry, settings); assertThat(indexAnalyzers.get("default").analyzer(), is(instanceOf(KeywordAnalyzer.class))); assertThat(indexAnalyzers.get("default_search").analyzer(), is(instanceOf(EnglishAnalyzer.class))); + assertWarnings("setting [index.analysis.analyzer.foobar.alias] is only allowed on index [test] because it was created before " + + "5.x; analyzer aliases can no longer be created on new indices.", + "setting [index.analysis.analyzer.foobar_search.alias] is only allowed on index [test] because it was created before " + + "5.x; analyzer aliases can no longer be created on new indices."); } public void testAnalyzerAliasReferencesAlias() throws IOException { @@ -154,6 +158,10 @@ public void testAnalyzerAliasReferencesAlias() throws IOException { assertThat(indexAnalyzers.get("default").analyzer(), is(instanceOf(GermanAnalyzer.class))); // analyzer types are bound early before we resolve aliases assertThat(indexAnalyzers.get("default_search").analyzer(), is(instanceOf(StandardAnalyzer.class))); + assertWarnings("setting [index.analysis.analyzer.foobar.alias] is only allowed on index [test] because it was created before " + + "5.x; analyzer aliases can no longer be created on new indices.", + "setting [index.analysis.analyzer.foobar_search.alias] is only allowed on index [test] because it was created before " + + "5.x; analyzer aliases can no longer be created on new indices."); } public void testAnalyzerAliasDefault() throws IOException { @@ -168,6 +176,8 @@ public void testAnalyzerAliasDefault() throws IOException { IndexAnalyzers indexAnalyzers = getIndexAnalyzers(newRegistry, settings); assertThat(indexAnalyzers.get("default").analyzer(), is(instanceOf(KeywordAnalyzer.class))); assertThat(indexAnalyzers.get("default_search").analyzer(), is(instanceOf(KeywordAnalyzer.class))); + assertWarnings("setting [index.analysis.analyzer.foobar.alias] is only allowed on index [test] because it was created before " + + "5.x; analyzer aliases can no longer be created on new indices."); } public void testAnalyzerAliasMoreThanOnce() throws IOException { @@ -183,6 +193,10 @@ public void testAnalyzerAliasMoreThanOnce() throws IOException { AnalysisRegistry newRegistry = getNewRegistry(settings); IllegalStateException ise = expectThrows(IllegalStateException.class, () -> getIndexAnalyzers(newRegistry, settings)); assertEquals("alias [default] is already used by [foobar]", ise.getMessage()); + assertWarnings("setting [index.analysis.analyzer.foobar.alias] is only allowed on index [test] because it was created before " + + "5.x; analyzer aliases can no longer be created on new indices.", + "setting [index.analysis.analyzer.foobar1.alias] is only allowed on index [test] because it was created before " + + "5.x; analyzer aliases can no longer be created on new indices."); } public void testAnalyzerAliasNotAllowedPost5x() throws IOException { @@ -353,6 +367,8 @@ public void testUnderscoreInAnalyzerNameAlias() throws IOException { } catch (IllegalArgumentException e) { assertThat(e.getMessage(), equalTo("analyzer name must not start with '_'. got \"_invalid_name\"")); } + assertWarnings("setting [index.analysis.analyzer.valid_name.alias] is only allowed on index [test] because it was " + + "created before 5.x; analyzer aliases can no longer be created on new indices."); } public void testDeprecatedPositionOffsetGap() throws IOException { diff --git a/core/src/test/java/org/elasticsearch/search/builder/SearchSourceBuilderTests.java b/core/src/test/java/org/elasticsearch/search/builder/SearchSourceBuilderTests.java index 8ec873704d617..7817a9ed32a4e 100644 --- a/core/src/test/java/org/elasticsearch/search/builder/SearchSourceBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/search/builder/SearchSourceBuilderTests.java @@ -324,6 +324,7 @@ public void testParseIndicesBoost() throws IOException { assertEquals(2, searchSourceBuilder.indexBoosts().size()); assertEquals(new SearchSourceBuilder.IndexBoost("foo", 1.0f), searchSourceBuilder.indexBoosts().get(0)); assertEquals(new SearchSourceBuilder.IndexBoost("bar", 2.0f), searchSourceBuilder.indexBoosts().get(1)); + assertWarnings("Object format in indices_boost is deprecated, please use array format instead"); } } diff --git a/core/src/test/java/org/elasticsearch/search/sort/AbstractSortTestCase.java b/core/src/test/java/org/elasticsearch/search/sort/AbstractSortTestCase.java index d545a082b558b..452d914bb866a 100644 --- a/core/src/test/java/org/elasticsearch/search/sort/AbstractSortTestCase.java +++ b/core/src/test/java/org/elasticsearch/search/sort/AbstractSortTestCase.java @@ -25,7 +25,6 @@ import org.elasticsearch.cluster.metadata.IndexMetaData; import org.elasticsearch.common.ParseFieldMatcher; import org.elasticsearch.common.io.stream.NamedWriteableRegistry; -import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.xcontent.ToXContent; import org.elasticsearch.common.xcontent.XContentBuilder; @@ -251,6 +250,6 @@ protected static QueryBuilder randomNestedFilter() { @SuppressWarnings("unchecked") private T copy(T original) throws IOException { return copyWriteable(original, namedWriteableRegistry, - (Writeable.Reader) namedWriteableRegistry.getReader(SortBuilder.class, original.getWriteableName())); + namedWriteableRegistry.getReader(SortBuilder.class, original.getWriteableName())); } } diff --git a/core/src/test/java/org/elasticsearch/search/sort/GeoDistanceSortBuilderTests.java b/core/src/test/java/org/elasticsearch/search/sort/GeoDistanceSortBuilderTests.java index 131d19f600db8..ec3d2a01754ca 100644 --- a/core/src/test/java/org/elasticsearch/search/sort/GeoDistanceSortBuilderTests.java +++ b/core/src/test/java/org/elasticsearch/search/sort/GeoDistanceSortBuilderTests.java @@ -267,17 +267,15 @@ public void testCoerceIsDeprecated() throws IOException { " } ],\n" + " \"unit\" : \"m\",\n" + " \"distance_type\" : \"sloppy_arc\",\n" + - " \"mode\" : \"SUM\",\n" + + " \"mode\" : \"MAX\",\n" + " \"coerce\" : true\n" + "}"; XContentParser itemParser = createParser(JsonXContent.jsonXContent, json); itemParser.nextToken(); - QueryParseContext context = new QueryParseContext(indicesQueriesRegistry, itemParser, ParseFieldMatcher.STRICT); - - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> GeoDistanceSortBuilder.fromXContent(context, "")); - assertTrue(e.getMessage().startsWith("Deprecated field ")); - + QueryParseContext context = new QueryParseContext(indicesQueriesRegistry, itemParser, ParseFieldMatcher.EMPTY); + GeoDistanceSortBuilder.fromXContent(context, ""); + assertWarnings("Deprecated field [coerce] used, replaced by [validation_method]"); } public void testIgnoreMalformedIsDeprecated() throws IOException { @@ -288,17 +286,15 @@ public void testIgnoreMalformedIsDeprecated() throws IOException { " } ],\n" + " \"unit\" : \"m\",\n" + " \"distance_type\" : \"sloppy_arc\",\n" + - " \"mode\" : \"SUM\",\n" + + " \"mode\" : \"MAX\",\n" + " \"ignore_malformed\" : true\n" + "}"; XContentParser itemParser = createParser(JsonXContent.jsonXContent, json); itemParser.nextToken(); - QueryParseContext context = new QueryParseContext(indicesQueriesRegistry, itemParser, ParseFieldMatcher.STRICT); - - IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> GeoDistanceSortBuilder.fromXContent(context, "")); - assertTrue(e.getMessage().startsWith("Deprecated field ")); - + QueryParseContext context = new QueryParseContext(indicesQueriesRegistry, itemParser, ParseFieldMatcher.EMPTY); + GeoDistanceSortBuilder.fromXContent(context, ""); + assertWarnings("Deprecated field [ignore_malformed] used, replaced by [validation_method]"); } public void testSortModeSumIsRejectedInJSON() throws IOException { @@ -455,8 +451,8 @@ public void testGeoDistanceSortDeprecatedSortModeException() throws Exception { sortBuilder.field("unit", "km"); sortBuilder.field("sort_mode", "max"); sortBuilder.endObject(); - IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, () -> parse(sortBuilder)); - assertEquals("Deprecated field [sort_mode] used, expected [mode] instead", ex.getMessage()); + parse(sortBuilder); + assertWarnings("Deprecated field [sort_mode] used, expected [mode] instead"); } private GeoDistanceSortBuilder parse(XContentBuilder sortBuilder) throws Exception { diff --git a/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/MustacheScriptEngineTests.java b/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/MustacheScriptEngineTests.java index 6a936260ca575..701ee8d984fd3 100644 --- a/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/MustacheScriptEngineTests.java +++ b/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/MustacheScriptEngineTests.java @@ -87,7 +87,7 @@ public void testSimple() throws IOException { + "\"params\":{\"template\":\"all\"}" + "}"; XContentParser parser = createParser(JsonXContent.jsonXContent, templateString); - Script script = Script.parse(parser, new ParseFieldMatcher(false)); + Script script = Script.parse(parser, ParseFieldMatcher.EMPTY); CompiledScript compiledScript = new CompiledScript(ScriptType.INLINE, null, "mustache", qe.compile(null, script.getIdOrCode(), Collections.emptyMap())); ExecutableScript executableScript = qe.executable(compiledScript, script.getParams()); @@ -103,7 +103,7 @@ public void testParseTemplateAsSingleStringWithConditionalClause() throws IOExce + " }" + "}"; XContentParser parser = createParser(JsonXContent.jsonXContent, templateString); - Script script = Script.parse(parser, new ParseFieldMatcher(false)); + Script script = Script.parse(parser, ParseFieldMatcher.EMPTY); CompiledScript compiledScript = new CompiledScript(ScriptType.INLINE, null, "mustache", qe.compile(null, script.getIdOrCode(), Collections.emptyMap())); ExecutableScript executableScript = qe.executable(compiledScript, script.getParams()); diff --git a/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/SearchTemplateIT.java b/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/SearchTemplateIT.java index 5bed13c78dce9..09e160f34f713 100644 --- a/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/SearchTemplateIT.java +++ b/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/SearchTemplateIT.java @@ -294,6 +294,7 @@ public void testIndexedTemplate() throws Exception { SearchResponse sr = client().prepareSearch().setQuery(builder) .execute().actionGet(); assertHitCount(sr, 1); + assertWarnings("[template] query is deprecated, use search template api instead"); } // Relates to #10397 @@ -306,39 +307,36 @@ public void testIndexedTemplateOverwrite() throws Exception { .get(); client().admin().indices().prepareRefresh().get(); - int iterations = randomIntBetween(2, 11); - for (int i = 1; i < iterations; i++) { - assertAcked(client().admin().cluster().preparePutStoredScript() - .setScriptLang(MustacheScriptEngineService.NAME) - .setId("git01") - .setSource(new BytesArray("{\"template\":{\"query\": {\"match\": {\"searchtext\": {\"query\": \"{{P_Keyword1}}\"," + - "\"type\": \"ooophrase_prefix\"}}}}}"))); - - GetStoredScriptResponse getResponse = client().admin().cluster() - .prepareGetStoredScript(MustacheScriptEngineService.NAME, "git01").get(); - assertNotNull(getResponse.getStoredScript()); - - Map templateParams = new HashMap<>(); - templateParams.put("P_Keyword1", "dev"); - - ParsingException e = expectThrows(ParsingException.class, () -> new SearchTemplateRequestBuilder(client()) - .setRequest(new SearchRequest("testindex").types("test")) - .setScript("git01").setScriptType(ScriptType.STORED).setScriptParams(templateParams) - .get()); - assertThat(e.getMessage(), containsString("[match] query does not support type ooophrase_prefix")); - - assertAcked(client().admin().cluster().preparePutStoredScript() - .setScriptLang(MustacheScriptEngineService.NAME) - .setId("git01") - .setSource(new BytesArray("{\"query\": {\"match\": {\"searchtext\": {\"query\": \"{{P_Keyword1}}\"," + - "\"type\": \"phrase_prefix\"}}}}"))); - - SearchTemplateResponse searchResponse = new SearchTemplateRequestBuilder(client()) - .setRequest(new SearchRequest("testindex").types("test")) - .setScript("git01").setScriptType(ScriptType.STORED).setScriptParams(templateParams) - .get(); - assertHitCount(searchResponse.getResponse(), 1); - } + assertAcked(client().admin().cluster().preparePutStoredScript() + .setScriptLang(MustacheScriptEngineService.NAME) + .setId("git01") + .setSource(new BytesArray("{\"template\":{\"query\": {\"match_phrase_prefix\": " + + "{\"searchtext\": {\"query\": \"{{P_Keyword1}}\"," + + "\"unsupported\": \"unsupported\"}}}}}"))); + + GetStoredScriptResponse getResponse = client().admin().cluster() + .prepareGetStoredScript(MustacheScriptEngineService.NAME, "git01").get(); + assertNotNull(getResponse.getStoredScript()); + + Map templateParams = new HashMap<>(); + templateParams.put("P_Keyword1", "dev"); + + ParsingException e = expectThrows(ParsingException.class, () -> new SearchTemplateRequestBuilder(client()) + .setRequest(new SearchRequest("testindex").types("test")) + .setScript("git01").setScriptType(ScriptType.STORED).setScriptParams(templateParams) + .get()); + assertThat(e.getMessage(), containsString("[match_phrase_prefix] query does not support [unsupported]")); + + assertAcked(client().admin().cluster().preparePutStoredScript() + .setScriptLang(MustacheScriptEngineService.NAME) + .setId("git01") + .setSource(new BytesArray("{\"query\": {\"match_phrase_prefix\": {\"searchtext\": {\"query\": \"{{P_Keyword1}}\"}}}}"))); + + SearchTemplateResponse searchResponse = new SearchTemplateRequestBuilder(client()) + .setRequest(new SearchRequest("testindex").types("test")) + .setScript("git01").setScriptType(ScriptType.STORED).setScriptParams(templateParams) + .get(); + assertHitCount(searchResponse.getResponse(), 1); } public void testIndexedTemplateWithArray() throws Exception { diff --git a/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/TemplateQueryBuilderTests.java b/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/TemplateQueryBuilderTests.java index 34e06410a7808..4334de090c20e 100644 --- a/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/TemplateQueryBuilderTests.java +++ b/modules/lang-mustache/src/test/java/org/elasticsearch/script/mustache/TemplateQueryBuilderTests.java @@ -59,11 +59,12 @@ public class TemplateQueryBuilderTests extends AbstractQueryTestCase> extends ESTestCase { @@ -156,11 +152,6 @@ public abstract class AbstractQueryTestCase> private static String[] currentTypes; private static String[] randomTypes; - /** - * used to check warning headers of the deprecation logger - */ - private ThreadContext threadContext; - protected static Index getIndex() { return index; } @@ -187,7 +178,6 @@ public static void beforeClass() { .put(ScriptService.SCRIPT_AUTO_RELOAD_ENABLED_SETTING.getKey(), false) .build(); indexSettings = Settings.builder() - .put(ParseFieldMatcher.PARSE_STRICT, true) .put(IndexMetaData.SETTING_VERSION_CREATED, indexVersionCreated).build(); index = new Index(randomAsciiOfLengthBetween(1, 10), "_na_"); @@ -214,20 +204,6 @@ public void beforeTest() throws IOException { serviceHolder = new ServiceHolder(nodeSettings, indexSettings, getPlugins(), this); } serviceHolder.clientInvocationHandler.delegate = this; - this.threadContext = new ThreadContext(Settings.EMPTY); - DeprecationLogger.setThreadContext(threadContext); - } - - /** - * Check that there are no unaccounted warning headers. These should be checked with {@link #checkWarningHeaders(String...)} in the - * appropriate test - */ - @After - public void teardown() throws IOException { - final List warnings = threadContext.getResponseHeaders().get(DeprecationLogger.DEPRECATION_HEADER); - assertNull("unexpected warning headers", warnings); - DeprecationLogger.removeThreadContext(this.threadContext); - this.threadContext.close(); } private static SearchContext getSearchContext(String[] types, QueryShardContext context) { @@ -247,7 +223,7 @@ public IndexFieldDataService fieldData() { } @After - public void afterTest() { + public void afterTest() throws IOException { serviceHolder.clientInvocationHandler.delegate = null; } @@ -1026,23 +1002,6 @@ protected Query rewrite(Query query) throws IOException { return query; } - protected void checkWarningHeaders(String... messages) { - final List warnings = threadContext.getResponseHeaders().get(DeprecationLogger.DEPRECATION_HEADER); - assertThat(warnings, hasSize(messages.length)); - for (String msg : messages) { - assertThat(warnings, hasItem(equalTo(msg))); - } - // "clear" current warning headers by setting a new ThreadContext - DeprecationLogger.removeThreadContext(this.threadContext); - try { - this.threadContext.close(); - } catch (IOException e) { - throw new RuntimeException(e); - } - this.threadContext = new ThreadContext(Settings.EMPTY); - DeprecationLogger.setThreadContext(this.threadContext); - } - private static class ServiceHolder implements Closeable { private final IndicesQueriesRegistry indicesQueriesRegistry; diff --git a/test/framework/src/main/java/org/elasticsearch/test/ESIntegTestCase.java b/test/framework/src/main/java/org/elasticsearch/test/ESIntegTestCase.java index cb31ac6028bbf..45ae84d7ee3f6 100644 --- a/test/framework/src/main/java/org/elasticsearch/test/ESIntegTestCase.java +++ b/test/framework/src/main/java/org/elasticsearch/test/ESIntegTestCase.java @@ -339,6 +339,13 @@ public static void beforeClass() throws Exception { initializeSuiteScope(); } + @Override + protected final boolean enableWarningsCheck() { + //In an integ test it doesn't make sense to keep track of warnings: if the cluster is external the warnings are in another jvm, + //if the cluster is internal the deprecation logger is shared across all nodes + return false; + } + protected final void beforeInternal() throws Exception { final Scope currentClusterScope = getCurrentClusterScope(); switch (currentClusterScope) { diff --git a/test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java b/test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java index 9a4085ff2e4a3..1002d66c5d0cc 100644 --- a/test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java +++ b/test/framework/src/main/java/org/elasticsearch/test/ESTestCase.java @@ -57,12 +57,14 @@ import org.elasticsearch.common.io.stream.NamedWriteableRegistry; import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.Writeable; +import org.elasticsearch.common.logging.DeprecationLogger; import org.elasticsearch.common.logging.Loggers; import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.transport.TransportAddress; import org.elasticsearch.common.util.MockBigArrays; import org.elasticsearch.common.util.MockPageCacheRecycler; import org.elasticsearch.common.xcontent.XContent; +import org.elasticsearch.common.util.concurrent.ThreadContext; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentParser; @@ -129,6 +131,8 @@ import static org.elasticsearch.common.util.CollectionUtils.arrayAsArrayList; import static org.hamcrest.Matchers.empty; import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.hasItem; +import static org.hamcrest.Matchers.hasSize; /** * Base testcase for randomized unit testing with Elasticsearch @@ -173,6 +177,7 @@ public static void resetPortCounter() { } protected final Logger logger = Loggers.getLogger(getClass()); + private ThreadContext threadContext; // ----------------------------------------------------------------- // Suite and test case setup/cleanup. @@ -251,16 +256,62 @@ public static void restoreContentType() { @Before public final void before() { logger.info("[{}]: before test", getTestName()); + if (enableWarningsCheck()) { + this.threadContext = new ThreadContext(Settings.EMPTY); + DeprecationLogger.setThreadContext(threadContext); + } + } + + /** + * Whether or not we check after each test whether it has left warnings behind. That happens if any deprecated feature or syntax + * was used by the test and the test didn't assert on it using {@link #assertWarnings(String...)}. + */ + protected boolean enableWarningsCheck() { + return true; } @After public final void after() throws Exception { checkStaticState(); + if (enableWarningsCheck()) { + ensureNoWarnings(); + } ensureAllSearchContextsReleased(); ensureCheckIndexPassed(); logger.info("[{}]: after test", getTestName()); } + private void ensureNoWarnings() throws IOException { + //Check that there are no unaccounted warning headers. These should be checked with {@link #checkWarningHeaders(String...)} in the + //appropriate test + try { + final List warnings = threadContext.getResponseHeaders().get(DeprecationLogger.WARNING_HEADER); + assertNull("unexpected warning headers", warnings); + } finally { + DeprecationLogger.removeThreadContext(this.threadContext); + this.threadContext.close(); + } + } + + protected final void assertWarnings(String... expectedWarnings) throws IOException { + if (enableWarningsCheck() == false) { + throw new IllegalStateException("unable to check warning headers if the test is not set to do so"); + } + try { + final List actualWarnings = threadContext.getResponseHeaders().get(DeprecationLogger.WARNING_HEADER); + assertThat(actualWarnings, hasSize(expectedWarnings.length)); + for (String msg : expectedWarnings) { + assertThat(actualWarnings, hasItem(equalTo(msg))); + } + } finally { + // "clear" current warning headers by setting a new ThreadContext + DeprecationLogger.removeThreadContext(this.threadContext); + this.threadContext.close(); + this.threadContext = new ThreadContext(Settings.EMPTY); + DeprecationLogger.setThreadContext(this.threadContext); + } + } + private static final List statusData = new ArrayList<>(); static { // ensure that the status logger is set to the warn level so we do not miss any warnings with our Log4j usage