Be strict when parsing values searching for booleans

core/src/main/java/org/elasticsearch/index/mapper/BooleanFieldMapper.java

@@ -152,16 +152,15 @@ public BytesRef indexedValueForSearch(Object value) {
             } else {
                 sValue = value.toString();
             }
-            if (sValue.length() == 0) {
-                return Values.FALSE;
-            }
-            if (sValue.length() == 1 && sValue.charAt(0) == 'F') {
-                return Values.FALSE;
-            }
-            if (Booleans.parseBoolean(sValue, false)) {
-                return Values.TRUE;
+            switch (sValue) {
+                case "true":
+                    return Values.TRUE;
+                case "false":
+                    return Values.FALSE;
+                default:
+                    throw new IllegalArgumentException("Can't parse boolean value [" +
+                                    sValue + "], expected [true] or [false]");
             }
-            return Values.FALSE;
         }
 
         @Override

core/src/test/java/org/elasticsearch/index/mapper/ExternalValuesMapperIntegrationIT.java

@@ -106,7 +106,7 @@ public void testExternalValues() throws Exception {
         SearchResponse response;
 
         response = client().prepareSearch("test-idx")
-                .setPostFilter(QueryBuilders.termQuery("field.bool", "T"))
+                .setPostFilter(QueryBuilders.termQuery("field.bool", "true"))
                 .execute().actionGet();
 
         assertThat(response.getHits().totalHits(), equalTo((long) 1));

core/src/test/java/org/elasticsearch/search/query/QueryStringIT.java

@@ -247,6 +247,14 @@ public void testPhraseQueryOnFieldWithNoPositions() throws Exception {
         assertHitCount(resp, 1L);
     }
 
+    public void testBooleanStrictQuery() throws Exception {
+        Exception e = expectThrows(Exception.class, () ->
+                client().prepareSearch("test").setQuery(
+                        queryStringQuery("foo").field("f_bool")).get());
+        assertThat(ExceptionsHelper.detailedMessage(e),
+                containsString("Can't parse boolean value [foo], expected [true] or [false]"));
+    }
+
     private void assertHits(SearchHits hits, String... ids) {
         assertThat(hits.totalHits(), equalTo((long) ids.length));
         Set<String> hitIds = new HashSet<>();

docs/reference/mapping/types/boolean.asciidoc

@@ -32,21 +32,21 @@ PUT my_index
 
 POST my_index/my_type/1
 {
-  "is_published": true <1>
+  "is_published": 1 <1>
 }
 
 GET my_index/_search
 {
   "query": {
     "term": {
-      "is_published": 1 <2>
+      "is_published": true <2>
     }
   }
 }
 --------------------------------------------------
 // CONSOLE
-<1> Indexing a document with a JSON `true`.
-<2> Querying for the document with `1`, which is interpreted as `true`.
+<1> Indexing a document with `1`, which is interpreted as `true`.
+<1> Searching for documents with a JSON `true`.
 
 Aggregations like the <<search-aggregations-bucket-terms-aggregation,`terms`
 aggregation>>  use `1` and `0` for the `key`, and the strings `"true"` and

docs/reference/migration/migrate_6_0/search.asciidoc

@@ -5,3 +5,7 @@
 
 * The `collect_payloads` parameter of the `span_near` query has been removed. Payloads will be
   loaded when needed.
+
+* Queries on boolean fields now strictly parse boolean-like values. This means
+  only the strings `"true"` and `"false"` will be parsed into their boolean
+  counterparts. Other strings will cause an error to be thrown.