1 files changed, 53 insertions, 55 deletions
diff --git a/container-search/src/test/java/com/yahoo/search/yql/MinimalQueryInserterTestCase.java b/container-search/src/test/java/com/yahoo/search/yql/MinimalQueryInserterTestCase.java
index 1ef9fe5832f..1e6e29bb700 100644
--- a/container-search/src/test/java/com/yahoo/search/yql/MinimalQueryInserterTestCase.java
+++ b/container-search/src/test/java/com/yahoo/search/yql/MinimalQueryInserterTestCase.java
@@ -18,19 +18,17 @@ import com.yahoo.search.query.Sorting.UcaSorter;
 import com.yahoo.search.result.ErrorMessage;
 import com.yahoo.search.searchchain.Execution;
 import org.apache.http.client.utils.URIBuilder;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * Smoke test for first generation YQL+ integration.
@@ -41,14 +39,14 @@ public class MinimalQueryInserterTestCase {
     private Execution.Context context;
     private Execution execution;
 
-    @Before
+    @BeforeEach
     public void setUp() throws Exception {
         searchChain = new Chain<>(new MinimalQueryInserter());
         context = Execution.Context.createContextStub();
         execution = new Execution(searchChain, context);
     }
 
-    @After
+    @AfterEach
     public void tearDown() {
         searchChain = null;
         context = null;
@@ -56,7 +54,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void requireThatGroupingStepsAreAttachedToQuery() {
+    void requireThatGroupingStepsAreAttachedToQuery() {
         URIBuilder builder = new URIBuilder();
         builder.setPath("search/");
 
@@ -70,24 +68,24 @@ public class MinimalQueryInserterTestCase {
         assertEquals("foo", query.getPresentation().getSummaryFields().toArray(new String[1])[0]);
 
         builder.setParameter("yql", "select foo from bar where baz contains 'cox' " +
-                                    "| all(group(a) each(output(count())))");
+                "| all(group(a) each(output(count())))");
         query = new Query(builder.toString());
         execution.search(query);
         assertEquals("baz:cox", query.getModel().getQueryTree().toString());
         assertGrouping("[[]all(group(a) each(output(count())))]", query);
 
         builder.setParameter("yql", "select foo from bar where baz contains 'cox' " +
-                                    "| all(group(a) each(output(count()))) " +
-                                    "| all(group(b) each(output(count())))");
+                "| all(group(a) each(output(count()))) " +
+                "| all(group(b) each(output(count())))");
         query = new Query(builder.toString());
         execution.search(query);
         assertEquals("baz:cox", query.getModel().getQueryTree().toString());
         assertGrouping("[[]all(group(a) each(output(count())))," +
-                       " []all(group(b) each(output(count())))]", query);
+                " []all(group(b) each(output(count())))]", query);
     }
 
     @Test
-    public void requireThatGroupingContinuationsAreAttachedToQuery() {
+    void requireThatGroupingContinuationsAreAttachedToQuery() {
         URIBuilder builder = new URIBuilder();
         builder.setPath("search/");
 
@@ -98,36 +96,36 @@ public class MinimalQueryInserterTestCase {
         assertGrouping("[]", query);
 
         builder.setParameter("yql", "select foo from bar where baz contains 'cox' " +
-                                    "| { continuations:['BCBCBCBEBG', 'BCBKCBACBKCCK'] }" +
-                                    "all(group(a) each(output(count())))");
+                "| { continuations:['BCBCBCBEBG', 'BCBKCBACBKCCK'] }" +
+                "all(group(a) each(output(count())))");
         query = new Query(builder.toString());
         execution.search(query);
         assertEquals("baz:cox", query.getModel().getQueryTree().toString());
         assertGrouping("[[BCBCBCBEBG, BCBKCBACBKCCK]all(group(a) each(output(count())))]", query);
 
         builder.setParameter("yql", "select foo from bar where baz contains 'cox' " +
-                                    "| { continuations:['BCBCBCBEBG', 'BCBKCBACBKCCK'] }" +
-                                    "all(group(a) each(output(count()))) " +
-                                    "| { continuations:['BCBBBBBDBF', 'BCBJBPCBJCCJ'] }" +
-                                    "all(group(b) each(output(count())))");
+                "| { continuations:['BCBCBCBEBG', 'BCBKCBACBKCCK'] }" +
+                "all(group(a) each(output(count()))) " +
+                "| { continuations:['BCBBBBBDBF', 'BCBJBPCBJCCJ'] }" +
+                "all(group(b) each(output(count())))");
         query = new Query(builder.toString());
         execution.search(query);
         assertEquals("baz:cox", query.getModel().getQueryTree().toString());
         assertGrouping("[[BCBCBCBEBG, BCBKCBACBKCCK]all(group(a) each(output(count())))," +
-                       " [BCBBBBBDBF, BCBJBPCBJCCJ]all(group(b) each(output(count())))]", query);
+                " [BCBBBBBDBF, BCBJBPCBJCCJ]all(group(b) each(output(count())))]", query);
     }
 
-    @Test
-    @Ignore
     // TODO: YQL work in progress (jon)
-    public void testTmp() {
+    @Test
+    @Disabled
+    void testTmp() {
         Query query = new Query("search/?query=easilyRecognizedString&yql=select%20ignoredfield%20from%20ignoredsource%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         //execution.search(query);
         assertEquals("AND title:madonna easilyRecognizedString", query.getModel().getQueryTree().toString());
     }
 
     @Test
-    public void testSearch() {
+    void testSearch() {
         Query query = new Query("search/?query=easilyRecognizedString&yql=select%20ignoredfield%20from%20ignoredsource%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
         assertEquals("AND title:madonna (WEAKAND(100) easilyRecognizedString)", query.getModel().getQueryTree().toString());
@@ -135,25 +133,25 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testExplicitLanguageIsHonoredWithVerbatimQuery() {
+    void testExplicitLanguageIsHonoredWithVerbatimQuery() {
         String japaneseWord = "\u30ab\u30bf\u30ab\u30ca";
         Query query = new Query("search/?language=ja" + "&yql=select%20ignoredField%20from%20ignoredsource%20where%20title%20contains%20%22" + encode(japaneseWord) + "%22");
         execution.search(query);
         assertEquals(Language.JAPANESE, query.getModel().getParsingLanguage());
-        assertEquals("title:"+ japaneseWord, query.getModel().getQueryTree().toString());
+        assertEquals("title:" + japaneseWord, query.getModel().getQueryTree().toString());
     }
 
     @Test
-    public void testUserLanguageIsDetectedWithVerbatimQuery() {
+    void testUserLanguageIsDetectedWithVerbatimQuery() {
         String japaneseWord = "\u30ab\u30bf\u30ab\u30ca";
         Query query = new Query("search/?yql=select%20ignoredField%20from%20ignoredsource%20where%20title%20contains%20%22" + encode(japaneseWord) + "%22");
         execution.search(query);
         assertEquals(Language.JAPANESE, query.getModel().getParsingLanguage());
-        assertEquals("title:"+ japaneseWord, query.getModel().getQueryTree().toString());
+        assertEquals("title:" + japaneseWord, query.getModel().getQueryTree().toString());
     }
 
     @Test
-    public void testUserLanguageIsDetectedWithUserInput() {
+    void testUserLanguageIsDetectedWithUserInput() {
         String japaneseWord = "\u30ab\u30bf\u30ab\u30ca";
         Query query = new Query("search/?userString=" + encode(japaneseWord) + "&yql=select%20ignoredfield%20from%20ignoredsource%20where%20title%20contains%20%22madonna%22%20and%20userInput(@userString)");
         execution.search(query);
@@ -162,7 +160,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testUserLanguageIsDetectedWithUserQuery() {
+    void testUserLanguageIsDetectedWithUserQuery() {
         String japaneseWord = "\u30ab\u30bf\u30ab\u30ca";
         Query query = new Query("search/?query=" + encode(japaneseWord) + "&yql=select%20ignoredfield%20from%20ignoredsource%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
@@ -171,14 +169,14 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testUserQueryFailsWithoutArgument() {
+    void testUserQueryFailsWithoutArgument() {
         Query query = new Query("search/?query=easilyRecognizedString&yql=select%20ignoredfield%20from%20ignoredsource%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
         assertEquals("AND title:madonna (WEAKAND(100) easilyRecognizedString)", query.getModel().getQueryTree().toString());
     }
 
     @Test
-    public void testSearchFromAllSourcesWithUserSource() {
+    void testSearchFromAllSourcesWithUserSource() {
         Query query = new Query("search/?query=easilyRecognizedString&sources=abc&yql=select%20ignoredfield%20from%20sources%20*%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
         assertEquals("AND title:madonna (WEAKAND(100) easilyRecognizedString)", query.getModel().getQueryTree().toString());
@@ -186,7 +184,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testSearchFromAllSourcesWithoutUserSource() {
+    void testSearchFromAllSourcesWithoutUserSource() {
         Query query = new Query("search/?query=easilyRecognizedString&yql=select%20ignoredfield%20from%20sources%20*%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
         assertEquals("AND title:madonna (WEAKAND(100) easilyRecognizedString)", query.getModel().getQueryTree().toString());
@@ -194,7 +192,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testSearchFromSomeSourcesWithoutUserSource() {
+    void testSearchFromSomeSourcesWithoutUserSource() {
         Query query = new Query("search/?query=easilyRecognizedString&yql=select%20ignoredfield%20from%20sources%20sourceA,%20sourceB%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
         assertEquals("AND title:madonna (WEAKAND(100) easilyRecognizedString)", query.getModel().getQueryTree().toString());
@@ -204,7 +202,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testSearchFromSomeSourcesWithUserSource() {
+    void testSearchFromSomeSourcesWithUserSource() {
         Query query = new Query("search/?query=easilyRecognizedString&sources=abc&yql=select%20ignoredfield%20from%20sources%20sourceA,%20sourceB%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
         assertEquals("AND title:madonna (WEAKAND(100) easilyRecognizedString)", query.getModel().getQueryTree().toString());
@@ -215,7 +213,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public final void testSearchFromSomeSourcesWithOverlappingUserSource() {
+    final void testSearchFromSomeSourcesWithOverlappingUserSource() {
         final Query query = new Query("search/?query=easilyRecognizedString&sources=abc,sourceA&yql=select%20ignoredfield%20from%20sources%20sourceA,%20sourceB%20where%20title%20contains%20%22madonna%22%20and%20userQuery()");
         execution.search(query);
         assertEquals("AND title:madonna (WEAKAND(100) easilyRecognizedString)", query.getModel().getQueryTree().toString());
@@ -226,17 +224,17 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testLimitAndOffset() {
+    void testLimitAndOffset() {
         Query query = new Query("search/?yql=select%20*%20from%20sources%20*%20where%20title%20contains%20%22madonna%22%20limit%2031offset%207");
         execution.search(query);
         assertEquals(7, query.getOffset());
         assertEquals(24, query.getHits());
         assertEquals("select * from sources * where title contains \"madonna\" limit 31 offset 7",
-                     query.yqlRepresentation());
+                query.yqlRepresentation());
     }
 
     @Test
-    public void testMaxOffset() {
+    void testMaxOffset() {
         Query query = new Query("search/?yql=select%20*%20from%20sources%20*%20where%20title%20contains%20%22madonna%22%20limit%2040031offset%2040000");
         Result r = execution.search(query);
         assertEquals(1, r.hits().getErrorHit().errors().size());
@@ -246,7 +244,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testMaxLimit() {
+    void testMaxLimit() {
         Query query = new Query("search/?yql=select%20*%20from%20sources%20*%20where%20title%20contains%20%22madonna%22%20limit%2040000offset%207");
         Result r = execution.search(query);
         assertEquals(1, r.hits().getErrorHit().errors().size());
@@ -256,7 +254,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testTimeout() {
+    void testTimeout() {
         Query query = new Query("search/?yql=select%20*%20from%20sources%20*%20where%20title%20contains%20%22madonna%22%20timeout%2051");
         execution.search(query);
         assertEquals(51L, query.getTimeout());
@@ -264,12 +262,12 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testTimeoutWithGrouping() {
+    void testTimeoutWithGrouping() {
         var select = "select x, y, z from sources * "
                 + "where (x > 0 AND y contains \"foo\" AND z contains \"bar\") "
                 + "order by x limit 20 offset 10 timeout 30 "
                 + "| all(group(y) max(3) each(output(count())))";
-        Query query = new Query("search/?yql="+ URLEncoder.encode(select, Charsets.UTF_8));
+        Query query = new Query("search/?yql=" + URLEncoder.encode(select, Charsets.UTF_8));
         execution.search(query);
 
         assertEquals(10, query.getHits());
@@ -281,7 +279,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testOrdering() {
+    void testOrdering() {
         {
             String yql = "select%20ignoredfield%20from%20ignoredsource%20where%20title%20contains%20%22madonna%22%20order%20by%20something%2C%20shoesize%20desc%20limit%20300%20timeout%203";
             Query query = new Query("search/?yql=" + yql);
@@ -335,28 +333,28 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void testStringRepresentation() {
+    void testStringRepresentation() {
         String yql = "select%20ignoredfield%20from%20ignoredsource%20where%20title%20contains%20%22madonna%22%20order%20by%20something%2C%20shoesize%20desc%20limit%20300%20timeout%203";
         Query query = new Query("search/?yql=" + yql);
         execution.search(query);
         assertEquals("select ignoredfield from ignoredsource where title contains \"madonna\" order by something, shoesize desc limit 300 timeout 3",
-                     query.yqlRepresentation());
+                query.yqlRepresentation());
     }
 
     @Test
-    public void testAndSegmenting() {
+    void testAndSegmenting() {
         Query query = new Query("?yql=select%20%2A%20from%20sources%20%2A%20where%20%5B%7B%22defaultIndex%22%3A%20%22default%22%2C%22grammar%22%3A%20%22web%22%2C%22stem%22%3A%20true%2C%22allowEmpty%22%3A%20true%7D%5DuserInput%28%40animal%29%3B&animal=m%26m%27s&tracelevel=3");
         execution.search(query);
         assertEquals("select * from sources * where (default contains \"m\" AND default contains ({origin: {original: \"m\\'s\", offset: 0, length: 3}, andSegmenting: true}phrase(\"m\", \"s\")))",
-                     query.yqlRepresentation());
+                query.yqlRepresentation());
     }
 
     @Test
-    public void globalMaxGroupsIsCarriedOver() {
+    void globalMaxGroupsIsCarriedOver() {
         URIBuilder builder = new URIBuilder();
         builder.setPath("search/");
         builder.setParameter("yql", "select foo from bar where baz contains 'cox' " +
-                                    "| all(group(a) each(output(count())))");
+                "| all(group(a) each(output(count())))");
         Query query = new Query(builder.toString());
         query.properties().set("grouping.globalMaxGroups", -1);
         execution.search(query);
@@ -365,12 +363,12 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void globalMaxGroupsCannotBeSetInRequest() {
+    void globalMaxGroupsCannotBeSetInRequest() {
         try {
             URIBuilder builder = new URIBuilder();
             builder.setPath("search/");
             builder.setParameter("yql", "select foo from bar where baz contains 'cox' " +
-                                        "| all(group(a) each(output(count())))");
+                    "| all(group(a) each(output(count())))");
             builder.setParameter("grouping.globalMaxGroups", "-1");
             Query query = new Query(builder.toString());
             execution.search(query);
@@ -382,7 +380,7 @@ public class MinimalQueryInserterTestCase {
     }
 
     @Test
-    public void verifyThatWarmupIsSane() {
+    void verifyThatWarmupIsSane() {
         assertTrue(MinimalQueryInserter.warmup());
     }