[TEST] add warnings check to ESTestCase

We are currenlty checking that no deprecation warnings are emitted in our query tests. That can be moved to ESTestCase (disabled in ESIntegTestCase) as it allows us to easily catch where our tests use deprecated features and assert on the expected warnings.

Author: javanna

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<ThreadContext> 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
                 }

core/src/main/java/org/elasticsearch/common/xcontent/NamedXContentRegistry.java

@@ -153,7 +153,7 @@ public <T, C> T parseNamedObject(Class<T> categoryClass, String name, XContentPa
         if (entry == null) {
             throw new UnknownNamedObjectException(parser.getTokenLocation(), categoryClass, name);
         }
-        if (false == entry.name.match(name, false)) {
+        if (false == entry.name.match(name)) {
             /* Note that this shouldn't happen because we already looked up the entry using the names but we need to call `match` anyway
              * because it is responsible for logging deprecation warnings. */
             throw new ParsingException(parser.getTokenLocation(),

core/src/test/java/org/elasticsearch/action/admin/indices/template/BWCTemplateTests.java

@@ -42,6 +42,7 @@ 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 {
@@ -53,6 +54,7 @@ public void testLogstashTemplatesBWC() throws Exception {
 
         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]");
     }
 
 }

core/src/test/java/org/elasticsearch/common/ParseFieldTests.java

@@ -20,13 +20,15 @@
 
 import org.elasticsearch.test.ESTestCase;
 
+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"};
@@ -42,33 +44,21 @@ public void testParse() {
         assertThat(withDeprecations.match("foo bar"), is(false));
         for (String deprecatedName : deprecated) {
             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");
-        }
-
-        assertThat(field.match(randomFrom(allValues)), is(true));
-        assertThat(field.match("not a field name"), is(false));
+        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() {

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<String, List<String>> 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<String> responses = responseHeaders.get(DeprecationLogger.DEPRECATION_HEADER);
+            List<String> 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<String, List<String>> responseHeaders = threadContext.getResponseHeaders();
-            List<String> responses = responseHeaders.get(DeprecationLogger.DEPRECATION_HEADER);
+            List<String> 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));

core/src/test/java/org/elasticsearch/common/xcontent/ObjectParserTests.java

@@ -22,9 +22,6 @@
 import org.elasticsearch.common.ParseFieldMatcher;
 import org.elasticsearch.common.ParseFieldMatcherSupplier;
 import org.elasticsearch.common.ParsingException;
-import org.elasticsearch.common.logging.DeprecationLogger;
-import org.elasticsearch.common.settings.Settings;
-import org.elasticsearch.common.util.concurrent.ThreadContext;
 import org.elasticsearch.common.xcontent.AbstractObjectParser.NoContextParser;
 import org.elasticsearch.common.xcontent.ObjectParser.NamedObjectParser;
 import org.elasticsearch.common.xcontent.ObjectParser.ValueType;
@@ -38,8 +35,6 @@
 import java.util.Arrays;
 import java.util.List;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasItem;
 import static org.hamcrest.Matchers.hasSize;
 
 public class ObjectParserTests extends ESTestCase {
@@ -224,26 +219,16 @@ public void setTest(int test) {
     }
 
     public void testDeprecationWarnings() throws IOException {
-        try (ThreadContext threadContext = new ThreadContext(Settings.EMPTY)) {
-            DeprecationLogger.setThreadContext(threadContext);
-            class TestStruct {
-                public String test;
-            }
-            ObjectParser<TestStruct, ParseFieldMatcherSupplier> objectParser = new ObjectParser<>("foo");
-            TestStruct s = new TestStruct();
-
-            objectParser.declareField((i, v, c) -> v.test = i.text(), new ParseField("test", "old_test"), ObjectParser.ValueType.STRING);
-
-            XContentParser parser = createParser(XContentType.JSON.xContent(), "{\"old_test\" : \"foo\"}");
-            objectParser.parse(parser, s, () -> ParseFieldMatcher.EMPTY);
-
-            assertEquals("foo", s.test);
-
-            final List<String> warnings = threadContext.getResponseHeaders().get(DeprecationLogger.DEPRECATION_HEADER);
-            assertThat(warnings, hasSize(1));
-            assertThat(warnings, hasItem(equalTo("Deprecated field [old_test] used, expected [test] instead")));
-            DeprecationLogger.removeThreadContext(threadContext);
+        class TestStruct {
+            public String test;
         }
+        ObjectParser<TestStruct, ParseFieldMatcherSupplier> 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);
+        objectParser.parse(parser, s, () -> ParseFieldMatcher.EMPTY);
+        assertEquals("foo", s.test);
+        assertWarnings("Deprecated field [old_test] used, expected [test] instead");
     }
 
     public void testFailOnValueType() throws IOException {

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 {

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;
@@ -49,7 +50,7 @@ public void testParseUnknownParam() throws Exception {
         assertEquals("{\"match_mapping_type\":\"string\",\"mapping\":{\"store\":true}}", builder.string());
     }
 
-    public void testParseUnknownMatchType() {
+    public void testParseUnknownMatchType() throws IOException {
         Map<String, Object> templateDef = new HashMap<>();
         templateDef.put("match_mapping_type", "short");
         templateDef.put("mapping", Collections.singletonMap("store", true));

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());
 

core/src/test/java/org/elasticsearch/index/query/BoolQueryBuilderTests.java

@@ -344,7 +344,7 @@ public void testFromJsonEmptyQueryBody() throws IOException {
         assertEquals(query, 0, queryBuilder.mustNot().size());
         assertEquals(query, 0, queryBuilder.should().size());
         // we should have deprecation warning headers regardless of throwing an exception
-        assertWarningHeaders("query malformed, empty clause found at [1:27]",
+        assertWarnings("query malformed, empty clause found at [1:27]",
                 "query malformed, empty clause found at [1:46]",
                 "query malformed, empty clause found at [1:100]");
     }