You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@druid.apache.org by al...@apache.org on 2026/08/08 17:07:47 UTC
(druid) branch master updated: test(sql): migrate SQL leaf and Quidem tests to JUnit 5 (#19909)
This is an automated email from the ASF dual-hosted git repository.
AlbericByte pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/druid.git
The following commit(s) were added to refs/heads/master by this push:
new b1b968365de test(sql): migrate SQL leaf and Quidem tests to JUnit 5 (#19909)
b1b968365de is described below
commit b1b968365de241f557a679634f125741424907fd
Author: Frank Chen <fr...@outlook.com>
AuthorDate: Sun Aug 9 01:07:41 2026 +0800
test(sql): migrate SQL leaf and Quidem tests to JUnit 5 (#19909)
* test(sql): migrate SQL leaf and Quidem tests to JUnit 5
* style(sql): tidy Hamcrest assertion import
* test(sql): remove unused parameterized arguments
* test(sql,server): migrate shared QueryStackTests to JUnit 5
* test: use JUnit 5 parameterized classes
---
quidem-ut/pom.xml | 13 +-
.../org/apache/druid/quidem/LauncherSmokeTest.java | 17 +-
.../CachingClusteredClientFunctionalityTest.java | 21 +-
.../druid/client/CachingClusteredClientTest.java | 81 +++--
.../apache/druid/client/DirectDruidClientTest.java | 141 ++++----
.../SegmentMetadataQuerySegmentWalkerTest.java | 20 +-
.../org/apache/druid/server/QueryStackTests.java | 15 +-
.../druid/quidem/DruidAvaticaDriverTest.java | 4 +-
.../druid/quidem/DruidQuidemCommandHandler.java | 4 +-
.../apache/druid/quidem/DruidQuidemTestBase.java | 8 +-
.../apache/druid/sql/SqlLifecycleManagerTest.java | 34 +-
.../org/apache/druid/sql/SqlQueryPlusTest.java | 18 +-
.../apache/druid/sql/SqlRowTransformerTest.java | 8 +-
.../org/apache/druid/sql/SqlStatementTest.java | 69 ++--
.../druid/sql/avatica/AvaticaModuleTest.java | 86 ++---
.../druid/sql/avatica/DruidAvaticaHandlerTest.java | 262 +++++++-------
.../druid/sql/avatica/DruidStatementTest.java | 84 ++---
.../apache/druid/sql/avatica/ErrorHandlerTest.java | 14 +-
.../aggregation/SqlAggregationModuleTest.java | 13 +-
.../calcite/expression/DruidExpressionTest.java | 110 +++---
.../calcite/expression/ExpressionTestHelper.java | 21 +-
.../sql/calcite/expression/ExpressionsTest.java | 25 +-
.../expression/IPv4AddressMatchExpressionTest.java | 18 +-
.../expression/IPv4AddressParseExpressionTest.java | 10 +-
.../IPv4AddressStringifyExpressionTest.java | 10 +-
.../expression/OperatorConversionsTest.java | 145 ++++----
.../external/ExternalTableScanRuleTest.java | 6 +-
.../filtration/CombineAndSimplifyBoundsTest.java | 2 +-
.../sql/calcite/filtration/FiltrationTest.java | 6 +-
.../druid/sql/calcite/http/SqlQueryTest.java | 8 +-
.../sql/calcite/parser/DruidSqlParserTest.java | 52 +--
.../calcite/parser/DruidSqlParserUtilsTest.java | 87 ++---
.../sql/calcite/parser/DruidSqlUnparseTest.java | 4 +-
.../calcite/planner/CalcitePlannerModuleTest.java | 17 +-
.../sql/calcite/planner/ColumnMappingTest.java | 2 +-
.../sql/calcite/planner/ColumnMappingsTest.java | 2 +-
.../druid/sql/calcite/planner/DruidHintTest.java | 14 +-
.../calcite/planner/DruidOperatorTableTest.java | 44 +--
.../sql/calcite/planner/DruidRexExecutorTest.java | 48 +--
.../druid/sql/calcite/planner/OffsetLimitTest.java | 22 +-
.../sql/calcite/planner/PlannerConfigTest.java | 18 +-
.../druid/sql/calcite/planner/TrivialTest.java | 4 +-
.../druid/sql/calcite/rel/DruidQueryTest.java | 10 +-
.../apache/druid/sql/calcite/rel/DruidRelTest.java | 42 +--
.../druid/sql/calcite/rel/DruidRelsTest.java | 73 ++--
.../apache/druid/sql/calcite/rel/GroupingTest.java | 2 +-
.../druid/sql/calcite/rule/DruidJoinRuleTest.java | 32 +-
.../calcite/rule/DruidLogicalValuesRuleTest.java | 99 +++--
.../calcite/rule/DruidUnionDataSourceRuleTest.java | 22 +-
.../rule/FilterDecomposeConcatRuleTest.java | 42 +--
.../rule/FilterJoinExcludePushToChildRuleTest.java | 16 +-
.../druid/sql/calcite/run/DruidHookTest.java | 2 +-
.../druid/sql/calcite/run/SqlResultsTest.java | 33 +-
.../druid/sql/calcite/util/SqlTestFramework.java | 1 +
.../sql/destination/ExportDestinationTest.java | 6 +-
.../sql/destination/TableDestinationTest.java | 6 +-
.../org/apache/druid/sql/guice/SqlModuleTest.java | 23 +-
.../apache/druid/sql/http/ResultFormatTest.java | 14 +-
.../apache/druid/sql/http/SqlHttpModuleTest.java | 22 +-
.../org/apache/druid/sql/http/SqlQueryTest.java | 93 ++---
.../org/apache/druid/sql/http/SqlResourceTest.java | 398 ++++++++++-----------
61 files changed, 1264 insertions(+), 1259 deletions(-)
diff --git a/quidem-ut/pom.xml b/quidem-ut/pom.xml
index b936d54169a..82c2352d0c8 100644
--- a/quidem-ut/pom.xml
+++ b/quidem-ut/pom.xml
@@ -449,19 +449,10 @@
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
</dependency>
- <dependency>
- <groupId>org.junit.vintage</groupId>
- <artifactId>junit-vintage-engine</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
</dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- </dependency>
<dependency>
<groupId>org.apache.calcite.avatica</groupId>
<artifactId>avatica</artifactId>
@@ -494,12 +485,12 @@
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest</artifactId>
- <scope>compile</scope>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-core</artifactId>
- <scope>compile</scope>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
diff --git a/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java b/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java
index 6402cd63e43..5e726da1182 100644
--- a/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java
+++ b/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java
@@ -26,26 +26,25 @@ import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
public class LauncherSmokeTest
{
private static Launcher launcher;
- @BeforeClass
+ @BeforeAll
public static void setUp() throws Exception
{
launcher = new Launcher("druidtest:///");
launcher.start();
}
- @AfterClass
+ @AfterAll
public static void tearDown()
{
launcher.shutdown();
@@ -71,6 +70,6 @@ public class LauncherSmokeTest
CloseableHttpResponse response = client.execute(request);
assertEquals(200, response.getStatusLine().getStatusCode());
String responseStr = EntityUtils.toString(response.getEntity());
- MatcherAssert.assertThat(responseStr, Matchers.containsString("\"version\":\""));
+ Assertions.assertTrue(responseStr.contains("\"version\":\""));
}
}
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
index 81d997c19fd..7fd831de9f7 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientFunctionalityTest.java
@@ -54,12 +54,13 @@ import org.apache.druid.timeline.partition.NoneShardSpec;
import org.apache.druid.timeline.partition.SingleElementPartitionChunk;
import org.easymock.EasyMock;
import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
import javax.annotation.Nullable;
+
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
@@ -80,10 +81,10 @@ public class CachingClusteredClientFunctionalityTest
private TimelineServerView serverView;
private Cache cache;
- @ClassRule
- public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+ @RegisterExtension
+ public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
- @Before
+ @BeforeEach
public void setUp()
{
timeline = new VersionedIntervalTimeline<>(Ordering.natural());
@@ -115,7 +116,7 @@ public class CachingClusteredClientFunctionalityTest
ResponseContext responseContext = ResponseContext.createEmpty();
runQuery(client, builder.build(), responseContext);
- Assert.assertNull(responseContext.getUncoveredIntervals());
+ Assertions.assertNull(responseContext.getUncoveredIntervals());
builder.intervals("2015-01-01/2015-01-03");
responseContext = ResponseContext.createEmpty();
@@ -164,8 +165,8 @@ public class CachingClusteredClientFunctionalityTest
for (String interval : intervals) {
expectedList.add(Intervals.of(interval));
}
- Assert.assertEquals(expectedList, context.getUncoveredIntervals());
- Assert.assertEquals(uncoveredIntervalsOverflowed, context.get(ResponseContext.Keys.UNCOVERED_INTERVALS_OVERFLOWED));
+ Assertions.assertEquals(expectedList, context.getUncoveredIntervals());
+ Assertions.assertEquals(uncoveredIntervalsOverflowed, context.get(ResponseContext.Keys.UNCOVERED_INTERVALS_OVERFLOWED));
}
private void addToTimeline(Interval interval, String version)
diff --git a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
index 94c259314de..877f5ae1970 100644
--- a/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/CachingClusteredClientTest.java
@@ -137,14 +137,15 @@ import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.Interval;
import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
import javax.annotation.Nullable;
+
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@@ -166,7 +167,8 @@ import java.util.stream.IntStream;
/**
*
*/
-@RunWith(Parameterized.class)
+@ParameterizedClass(name = "{0}")
+@MethodSource("constructorFeeder")
public class CachingClusteredClientTest
{
private static final ImmutableMap<String, Object> CONTEXT = ImmutableMap.of(
@@ -251,10 +253,11 @@ public class CachingClusteredClientTest
private static final Granularity PT1H_TZ_GRANULARITY = new PeriodGranularity(new Period("PT1H"), null, TIMEZONE);
private static final String TOP_DIM = "a_dim";
- @ClassRule
- public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+ @RegisterExtension
+ public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
- private final Random random;
+ private final int randomSeed;
+ private Random random;
private CachingClusteredClient client;
private Runnable queryCompletedCallback;
@@ -265,10 +268,9 @@ public class CachingClusteredClientTest
public CachingClusteredClientTest(int randomSeed)
{
- this.random = new Random(randomSeed);
+ this.randomSeed = randomSeed;
}
- @Parameterized.Parameters(name = "{0}")
public static Iterable<Object[]> constructorFeeder()
{
return Lists.transform(
@@ -284,9 +286,10 @@ public class CachingClusteredClientTest
);
}
- @Before
+ @BeforeEach
public void setUp()
{
+ this.random = new Random(randomSeed);
timeline = new VersionedIntervalTimeline<>(Ordering.natural());
serverView = EasyMock.createNiceMock(TimelineServerView.class);
cache = MapCache.create(100000);
@@ -557,8 +560,8 @@ public class CachingClusteredClientTest
getDefaultQueryRunner().run(QueryPlus.wrap(query), context);
- Assert.assertTrue("Capture cache keys", cacheKeyCapture.hasCaptured());
- Assert.assertTrue("Cache key below limit", ImmutableList.copyOf(cacheKeyCapture.getValue()).size() <= limit);
+ Assertions.assertTrue(cacheKeyCapture.hasCaptured(), "Capture cache keys");
+ Assertions.assertTrue(ImmutableList.copyOf(cacheKeyCapture.getValue()).size() <= limit, "Cache key below limit");
EasyMock.verify(cache);
@@ -572,8 +575,8 @@ public class CachingClusteredClientTest
getDefaultQueryRunner().run(QueryPlus.wrap(query), context);
EasyMock.verify(cache);
EasyMock.verify(dataSegment);
- Assert.assertTrue("Capture cache keys", cacheKeyCapture.hasCaptured());
- Assert.assertTrue("Cache Keys empty", ImmutableList.copyOf(cacheKeyCapture.getValue()).isEmpty());
+ Assertions.assertTrue(cacheKeyCapture.hasCaptured(), "Capture cache keys");
+ Assertions.assertTrue(ImmutableList.copyOf(cacheKeyCapture.getValue()).isEmpty(), "Cache Keys empty");
}
@Test
@@ -704,9 +707,9 @@ public class CachingClusteredClientTest
Intervals.of("2011-01-01/2011-01-02"), makeTimeResults(DateTimes.of("2011-01-01"), 50, 5000)
);
- Assert.assertEquals(1, cache.getStats().getNumEntries());
- Assert.assertEquals(0, cache.getStats().getNumHits());
- Assert.assertEquals(0, cache.getStats().getNumMisses());
+ Assertions.assertEquals(1, cache.getStats().getNumEntries());
+ Assertions.assertEquals(0, cache.getStats().getNumHits());
+ Assertions.assertEquals(0, cache.getStats().getNumMisses());
cache.close(SegmentId.dummy("0_0").toString());
@@ -723,9 +726,9 @@ public class CachingClusteredClientTest
Intervals.of("2011-01-01/2011-01-02"), makeTimeResults(DateTimes.of("2011-01-01"), 50, 5000)
);
- Assert.assertEquals(0, cache.getStats().getNumEntries());
- Assert.assertEquals(0, cache.getStats().getNumHits());
- Assert.assertEquals(0, cache.getStats().getNumMisses());
+ Assertions.assertEquals(0, cache.getStats().getNumEntries());
+ Assertions.assertEquals(0, cache.getStats().getNumHits());
+ Assertions.assertEquals(0, cache.getStats().getNumMisses());
testQueryCaching(
getDefaultQueryRunner(),
@@ -740,9 +743,9 @@ public class CachingClusteredClientTest
Intervals.of("2011-01-01/2011-01-02"), makeTimeResults(DateTimes.of("2011-01-01"), 50, 5000)
);
- Assert.assertEquals(0, cache.getStats().getNumEntries());
- Assert.assertEquals(0, cache.getStats().getNumHits());
- Assert.assertEquals(1, cache.getStats().getNumMisses());
+ Assertions.assertEquals(0, cache.getStats().getNumEntries());
+ Assertions.assertEquals(0, cache.getStats().getNumHits());
+ Assertions.assertEquals(1, cache.getStats().getNumMisses());
}
@Test
@@ -1423,7 +1426,7 @@ public class CachingClusteredClientTest
runner.run(QueryPlus.wrap(query)).toList();
- Assert.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
+ Assertions.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
}
@Test
@@ -1598,7 +1601,7 @@ public class CachingClusteredClientTest
MultipleSpecificSegmentSpec expected = new MultipleSpecificSegmentSpec(expcetedDescriptors);
runner.run(QueryPlus.wrap(query)).toList();
- Assert.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
+ Assertions.assertEquals(expected, ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec());
}
@Test
@@ -1717,11 +1720,11 @@ public class CachingClusteredClientTest
runner.run(QueryPlus.wrap(query)).toList();
QuerySegmentSpec querySegmentSpec = ((TimeseriesQuery) capture.getValue().getQuery()).getQuerySegmentSpec();
- Assert.assertSame(MultipleSpecificSegmentSpec.class, querySegmentSpec.getClass());
+ Assertions.assertSame(MultipleSpecificSegmentSpec.class, querySegmentSpec.getClass());
final Set<SegmentDescriptor> actualDescriptors = new HashSet<>(
((MultipleSpecificSegmentSpec) querySegmentSpec).getDescriptors()
);
- Assert.assertEquals(expcetedDescriptors, actualDescriptors);
+ Assertions.assertEquals(expcetedDescriptors, actualDescriptors);
}
private ServerSelector makeMockHashBasedSelector(
@@ -2163,9 +2166,9 @@ public class CachingClusteredClientTest
Query capturedQuery = capturedQueryPlus.getQuery();
final QueryContext queryContext = capturedQuery.context();
if (expectBySegment) {
- Assert.assertEquals(true, queryContext.getBoolean(QueryContexts.BY_SEGMENT_KEY));
+ Assertions.assertEquals(true, queryContext.getBoolean(QueryContexts.BY_SEGMENT_KEY));
} else {
- Assert.assertTrue(
+ Assertions.assertTrue(
queryContext.get(QueryContexts.BY_SEGMENT_KEY) == null ||
!queryContext.getBoolean(QueryContexts.BY_SEGMENT_KEY)
);
@@ -3050,7 +3053,7 @@ public class CachingClusteredClientTest
final ResponseContext responseContext = initializeResponseContext();
getDefaultQueryRunner().run(QueryPlus.wrap(query), responseContext);
- Assert.assertEquals("RsQmZHYstvXNeGf86z3pgpk+Wsg=", responseContext.getEntityTag());
+ Assertions.assertEquals("RsQmZHYstvXNeGf86z3pgpk+Wsg=", responseContext.getEntityTag());
}
@Test
@@ -3102,7 +3105,7 @@ public class CachingClusteredClientTest
final String etag1 = responseContext.getEntityTag();
getDefaultQueryRunner().run(QueryPlus.wrap(query2), responseContext);
final String etag2 = responseContext.getEntityTag();
- Assert.assertNotEquals(etag1, etag2);
+ Assertions.assertNotEquals(etag1, etag2);
}
@Test
@@ -3163,9 +3166,9 @@ public class CachingClusteredClientTest
getDefaultQueryRunner().run(QueryPlus.wrap(queryLegacyTrue), responseContext);
final Map<String, Integer> remainingResponseMap = (Map<String, Integer>) responseContext.get(ResponseContext.Keys.REMAINING_RESPONSES_FROM_QUERY_SERVERS);
- Assert.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
- Assert.assertEquals(0, remainingResponseMap.get(queryExclusive.getId()).intValue());
- Assert.assertEquals(0, remainingResponseMap.get(queryLegacyTrue.getId()).intValue());
+ Assertions.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
+ Assertions.assertEquals(0, remainingResponseMap.get(queryExclusive.getId()).intValue());
+ Assertions.assertEquals(0, remainingResponseMap.get(queryLegacyTrue.getId()).intValue());
}
@Test
@@ -3218,8 +3221,8 @@ public class CachingClusteredClientTest
getDefaultQueryRunner().run(QueryPlus.wrap(queryInclude), responseContext);
final Map<String, Integer> remainingResponseMap = (Map<String, Integer>) responseContext.get(ResponseContext.Keys.REMAINING_RESPONSES_FROM_QUERY_SERVERS);
- Assert.assertEquals(0, remainingResponseMap.get(queryExclude.getId()).intValue());
- Assert.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
+ Assertions.assertEquals(0, remainingResponseMap.get(queryExclude.getId()).intValue());
+ Assertions.assertEquals(1, remainingResponseMap.get(queryInclude.getId()).intValue());
}
@SuppressWarnings("unchecked")
diff --git a/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java b/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java
index fa835b009fd..55379a74fea 100644
--- a/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java
+++ b/server/src/test/java/org/apache/druid/client/DirectDruidClientTest.java
@@ -57,15 +57,15 @@ import org.apache.druid.timeline.DataSegment;
import org.apache.druid.timeline.SegmentId;
import org.jboss.netty.handler.codec.http.HttpMethod;
import org.jboss.netty.handler.timeout.ReadTimeoutException;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.io.TempDir;
import java.io.ByteArrayInputStream;
+import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.PipedInputStream;
@@ -79,11 +79,11 @@ import java.util.concurrent.TimeUnit;
public class DirectDruidClientTest
{
- @ClassRule
- public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+ @RegisterExtension
+ public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
+ @TempDir
+ public File temporaryFolder;
private final String hostName = "localhost:8080";
private final ObjectMapper objectMapper = new DefaultObjectMapper();
@@ -92,7 +92,7 @@ public class DirectDruidClientTest
private WrappingScheduledExecutorService queryCancellationExecutor;
private BlockingExecutorService blockingExecutorService;
- @Before
+ @BeforeEach
public void setup()
{
responseContext.initialize();
@@ -104,7 +104,7 @@ public class DirectDruidClientTest
);
}
- @After
+ @AfterEach
public void teardown() throws InterruptedException
{
blockingExecutorService.shutdownNow();
@@ -134,22 +134,22 @@ public class DirectDruidClientTest
Sequence s1 = client1.run(queryPlus, responseContext);
List<Request> requests = queuedHttpClient.getRequests();
- Assert.assertFalse(requests.isEmpty());
- Assert.assertEquals(url, requests.get(0).getUrl());
- Assert.assertEquals(HttpMethod.POST, requests.get(0).getMethod());
- Assert.assertEquals(1, client1.getNumOpenConnections());
+ Assertions.assertFalse(requests.isEmpty());
+ Assertions.assertEquals(url, requests.get(0).getUrl());
+ Assertions.assertEquals(HttpMethod.POST, requests.get(0).getMethod());
+ Assertions.assertEquals(1, client1.getNumOpenConnections());
// simulate read timeout on second request
client1.run(queryPlus, responseContext);
- Assert.assertEquals(2, client1.getNumOpenConnections());
+ Assertions.assertEquals(2, client1.getNumOpenConnections());
futureException.setException(new ReadTimeoutException());
- Assert.assertEquals(1, client1.getNumOpenConnections());
+ Assertions.assertEquals(1, client1.getNumOpenConnections());
// subsequent connections should work (and remain open)
client1.run(queryPlus, responseContext);
client1.run(queryPlus, responseContext);
client1.run(queryPlus, responseContext);
- Assert.assertEquals(4, client1.getNumOpenConnections());
+ Assertions.assertEquals(4, client1.getNumOpenConnections());
// produce result for first connection
futureResult.set(
@@ -158,13 +158,13 @@ public class DirectDruidClientTest
)
);
List<Result> results = s1.toList();
- Assert.assertEquals(1, results.size());
- Assert.assertEquals(DateTimes.of("2014-01-01T01:02:03Z"), results.get(0).getTimestamp());
- Assert.assertEquals(3, client1.getNumOpenConnections());
+ Assertions.assertEquals(1, results.size());
+ Assertions.assertEquals(DateTimes.of("2014-01-01T01:02:03Z"), results.get(0).getTimestamp());
+ Assertions.assertEquals(3, client1.getNumOpenConnections());
client2.run(queryPlus, responseContext);
client2.run(queryPlus, responseContext);
- Assert.assertEquals(2, client2.getNumOpenConnections());
+ Assertions.assertEquals(2, client2.getNumOpenConnections());
}
@Test
@@ -189,18 +189,18 @@ public class DirectDruidClientTest
DirectDruidClient client = makeDirectDruidClient(testHttpClient);
Sequence results = client.run(queryPlus, responseContext);
- Assert.assertEquals(0, client.getNumOpenConnections());
+ Assertions.assertEquals(0, client.getNumOpenConnections());
QueryInterruptedException actualException =
- Assert.assertThrows(QueryInterruptedException.class, () -> results.toList());
- Assert.assertEquals(hostName, actualException.getHost());
- Assert.assertEquals("Query cancelled", actualException.getErrorCode());
- Assert.assertEquals("Task was cancelled.", actualException.getCause().getMessage());
+ Assertions.assertThrows(QueryInterruptedException.class, () -> results.toList());
+ Assertions.assertEquals(hostName, actualException.getHost());
+ Assertions.assertEquals("Query cancelled", actualException.getErrorCode());
+ Assertions.assertEquals("Task was cancelled.", actualException.getCause().getMessage());
- Assert.assertTrue(blockingExecutorService.hasPendingTasks());
+ Assertions.assertTrue(blockingExecutorService.hasPendingTasks());
blockingExecutorService.finishNextPendingTask();
- Assert.assertTrue(blockingExecutorService.hasPendingTasks());
- ISE observedException = Assert.assertThrows(ISE.class, () -> blockingExecutorService.finishNextPendingTask());
- Assert.assertTrue(observedException.getCause() instanceof CancellationException);
+ Assertions.assertTrue(blockingExecutorService.hasPendingTasks());
+ ISE observedException = Assertions.assertThrows(ISE.class, () -> blockingExecutorService.finishNextPendingTask());
+ Assertions.assertTrue(observedException.getCause() instanceof CancellationException);
}
@@ -221,10 +221,10 @@ public class DirectDruidClientTest
Sequence results = client.run(getQueryPlus(), responseContext);
QueryInterruptedException actualException =
- Assert.assertThrows(QueryInterruptedException.class, () -> results.toList());
- Assert.assertEquals("testing1", actualException.getErrorCode());
- Assert.assertEquals("testing2", actualException.getMessage());
- Assert.assertEquals(hostName, actualException.getHost());
+ Assertions.assertThrows(QueryInterruptedException.class, () -> results.toList());
+ Assertions.assertEquals("testing1", actualException.getErrorCode());
+ Assertions.assertEquals("testing2", actualException.getMessage());
+ Assertions.assertEquals(hostName, actualException.getHost());
}
@Test
@@ -241,7 +241,7 @@ public class DirectDruidClientTest
final PipedOutputStream out = new PipedOutputStream(in);
timeoutFuture.set(in);
- QueryTimeoutException actualException = Assert.assertThrows(
+ QueryTimeoutException actualException = Assertions.assertThrows(
QueryTimeoutException.class,
() -> {
out.write(StringUtils.toUtf8("[{\"timestamp\":\"2014-01-01T01:02:03Z\"}"));
@@ -251,9 +251,9 @@ public class DirectDruidClientTest
results.toList();
}
);
- Assert.assertEquals("Query timeout", actualException.getErrorCode());
- Assert.assertEquals(StringUtils.format("url[http://%s/druid/v2/] timed out", hostName), actualException.getMessage());
- Assert.assertEquals(hostName, actualException.getHost());
+ Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+ Assertions.assertEquals(StringUtils.format("url[http://%s/druid/v2/] timed out", hostName), actualException.getMessage());
+ Assertions.assertEquals(hostName, actualException.getHost());
}
@Test
@@ -264,10 +264,10 @@ public class DirectDruidClientTest
QueryPlus query = getQueryPlus(Map.of(DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis() + 500));
Sequence results = client.run(query, responseContext);
- QueryTimeoutException actualException = Assert.assertThrows(QueryTimeoutException.class, results::toList);
- Assert.assertEquals("Query timeout", actualException.getErrorCode());
- Assert.assertEquals(StringUtils.format("Query [%s] timed out!", query.getQuery().getId()), actualException.getMessage());
- Assert.assertEquals(hostName, actualException.getHost());
+ QueryTimeoutException actualException = Assertions.assertThrows(QueryTimeoutException.class, results::toList);
+ Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+ Assertions.assertEquals(StringUtils.format("Query [%s] timed out!", query.getQuery().getId()), actualException.getMessage());
+ Assertions.assertEquals(hostName, actualException.getHost());
}
@Test
@@ -277,12 +277,12 @@ public class DirectDruidClientTest
final DirectDruidClient client = makeDirectDruidClient(initHttpClientFromExistingClient(timeoutFuture));
QueryPlus queryPlus = getQueryPlus(Map.of(DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis()));
- QueryTimeoutException actualException = Assert.assertThrows(
+ QueryTimeoutException actualException = Assertions.assertThrows(
QueryTimeoutException.class,
() -> client.run(queryPlus, responseContext)
);
- Assert.assertEquals("Query timeout", actualException.getErrorCode());
- Assert.assertEquals(
+ Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+ Assertions.assertEquals(
StringUtils.format(
"Query[%s] url[http://%s/druid/v2/] timed out.",
queryPlus.getQuery().getId(),
@@ -302,12 +302,12 @@ public class DirectDruidClientTest
DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis() + 100
));
- QueryTimeoutException actualException = Assert.assertThrows(
+ QueryTimeoutException actualException = Assertions.assertThrows(
QueryTimeoutException.class,
() -> client.run(queryPlus, responseContext)
);
- Assert.assertEquals("Query timeout", actualException.getErrorCode());
- Assert.assertEquals(
+ Assertions.assertEquals("Query timeout", actualException.getErrorCode());
+ Assertions.assertEquals(
StringUtils.format("Query[%s] url[http://%s/druid/v2/] timed out.",
queryPlus.getQuery().getId(),
hostName
@@ -320,8 +320,8 @@ public class DirectDruidClientTest
{
final DirectDruidClient client = makeDirectDruidClient(initHttpClientFromExistingClient());
- Assert.assertThrows(RuntimeException.class, () -> client.run(getQueryPlus(), responseContext));
- Assert.assertEquals(0, client.getNumOpenConnections());
+ Assertions.assertThrows(RuntimeException.class, () -> client.run(getQueryPlus(), responseContext));
+ Assertions.assertEquals(0, client.getNumOpenConnections());
}
@Test
@@ -332,8 +332,8 @@ public class DirectDruidClientTest
client.run(getQueryPlus(), responseContext).toList();
- Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
- Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
+ Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
+ Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
}
@Test
@@ -348,10 +348,10 @@ public class DirectDruidClientTest
DirectDruidClient.QUERY_FAIL_TIME, System.currentTimeMillis() + 50
));
- Assert.assertThrows(QueryTimeoutException.class, () -> client.run(queryPlus, responseContext));
+ Assertions.assertThrows(QueryTimeoutException.class, () -> client.run(queryPlus, responseContext));
- Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
- Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
+ Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
+ Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
}
@Test
@@ -372,10 +372,10 @@ public class DirectDruidClientTest
Sequence results = client.run(queryPlus, responseContext);
Thread.sleep(600);
- Assert.assertThrows(QueryTimeoutException.class, results::toList);
+ Assertions.assertThrows(QueryTimeoutException.class, results::toList);
- Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
- Assert.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
+ Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/time"));
+ Assertions.assertEquals(1, stubEmitter.getMetricEventCount("query/node/bytes"));
}
@Test
@@ -388,12 +388,12 @@ public class DirectDruidClientTest
DirectDruidClient.QUERY_FAIL_TIME, Long.MAX_VALUE
));
- ResourceLimitExceededException actualException = Assert.assertThrows(
+ ResourceLimitExceededException actualException = Assertions.assertThrows(
ResourceLimitExceededException.class,
() -> client.run(queryPlus, responseContext)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
StringUtils.format(
"Query[%s] url[http://localhost:8080/druid/v2/] total bytes gathered[127] exceeds maxScatterGatherBytes[100]",
queryPlus.getQuery().getId()
@@ -451,7 +451,7 @@ public class DirectDruidClientTest
{
try {
return IndexBuilder.create()
- .tmpDir(temporaryFolder.newFolder())
+ .tmpDir(newFolder(temporaryFolder, "junit"))
.segmentWriteOutMediumFactory(OffHeapMemorySegmentWriteOutMediumFactory.instance())
.schema(
new IncrementalIndexSchema.Builder()
@@ -465,7 +465,7 @@ public class DirectDruidClientTest
)
)
.inputFormat(TestIndex.DEFAULT_JSON_INPUT_FORMAT)
- .inputTmpDir(temporaryFolder.newFolder())
+ .inputTmpDir(newFolder(temporaryFolder, "junit"))
.buildMMappedIndex();
}
catch (IOException e) {
@@ -482,4 +482,15 @@ public class DirectDruidClientTest
{
return QueryPlus.wrap(Druids.newTimeBoundaryQueryBuilder().dataSource("test").context(context).randomQueryId().build());
}
+
+ private static File newFolder(File root, String... subDirs) throws IOException
+ {
+ if (subDirs.length == 0 || (subDirs.length == 1 && "junit".equals(subDirs[0]))) {
+ return org.apache.druid.java.util.common.FileUtils.createTempDirInLocation(root.toPath(), "junit");
+ }
+ String subFolder = String.join("/", subDirs);
+ File result = new File(root, subFolder);
+ org.apache.druid.java.util.common.FileUtils.mkdirp(result);
+ return result;
+ }
}
diff --git a/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java b/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java
index e2cbff4cb86..68581b909ee 100644
--- a/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java
+++ b/server/src/test/java/org/apache/druid/segment/metadata/SegmentMetadataQuerySegmentWalkerTest.java
@@ -63,10 +63,10 @@ import org.apache.druid.timeline.partition.SingleDimensionShardSpec;
import org.easymock.EasyMock;
import org.easymock.IAnswer;
import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.ClassRule;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
import org.mockito.Mockito;
import java.io.IOException;
@@ -90,10 +90,10 @@ public class SegmentMetadataQuerySegmentWalkerTest
private TestCoordinatorServerView testCoordinatorServerView;
private Module module;
- @ClassRule
- public static QueryStackTests.Junit4ConglomerateRule conglomerateRule = new QueryStackTests.Junit4ConglomerateRule();
+ @RegisterExtension
+ public static QueryStackTests.ConglomerateExtension conglomerateRule = new QueryStackTests.ConglomerateExtension();
- @Before
+ @BeforeEach
public void setUp()
{
DruidHttpClientConfig httpClientConfig = new DruidHttpClientConfig()
@@ -172,7 +172,7 @@ public class SegmentMetadataQuerySegmentWalkerTest
.map(ServerExpectation::getSegment)
.map(segment -> segment.getId().toString())
.collect(Collectors.toSet());
- Assert.assertEquals(expectedSegmentIds, actualSegmentIds);
+ Assertions.assertEquals(expectedSegmentIds, actualSegmentIds);
}
@Test
@@ -226,7 +226,7 @@ public class SegmentMetadataQuerySegmentWalkerTest
.map(ServerExpectation::getSegment)
.map(segment -> segment.getId().toString())
.collect(Collectors.toSet());
- Assert.assertEquals(expectedSegmentIds, actualSegmentIds);
+ Assertions.assertEquals(expectedSegmentIds, actualSegmentIds);
}
@Test
@@ -294,7 +294,7 @@ public class SegmentMetadataQuerySegmentWalkerTest
.map(ServerExpectation::getSegment)
.map(segment -> segment.getId().toString())
.collect(Collectors.toSet());
- Assert.assertEquals(expectedSegmentIds, actualSegmentIds);
+ Assertions.assertEquals(expectedSegmentIds, actualSegmentIds);
}
private Map<String, ServerExpectations> populateTimeline(
diff --git a/server/src/test/java/org/apache/druid/server/QueryStackTests.java b/server/src/test/java/org/apache/druid/server/QueryStackTests.java
index 2659f12def7..e64c554fcb3 100644
--- a/server/src/test/java/org/apache/druid/server/QueryStackTests.java
+++ b/server/src/test/java/org/apache/druid/server/QueryStackTests.java
@@ -104,10 +104,13 @@ import org.apache.druid.sql.calcite.util.CacheTestHelperModule.ResultCacheMode;
import org.apache.druid.timeline.DataSegment;
import org.apache.druid.timeline.VersionedIntervalTimeline;
import org.apache.druid.utils.JvmUtils;
-import org.junit.Assert;
-import org.junit.rules.ExternalResource;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.extension.AfterAllCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
import javax.annotation.Nullable;
+
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
@@ -118,20 +121,20 @@ import java.util.Set;
*/
public class QueryStackTests
{
- public static class Junit4ConglomerateRule extends ExternalResource
+ public static class ConglomerateExtension implements BeforeAllCallback, AfterAllCallback
{
private Closer closer;
private QueryRunnerFactoryConglomerate conglomerate;
@Override
- protected void before()
+ public void beforeAll(ExtensionContext context)
{
closer = Closer.create();
conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(closer);
}
@Override
- protected void after()
+ public void afterAll(ExtensionContext context)
{
try {
closer.close();
@@ -312,7 +315,7 @@ public class QueryStackTests
final TestBufferPool testBufferPool = TestBufferPool.offHeap(COMPUTE_BUFFER_SIZE, Integer.MAX_VALUE);
closer.register(() -> {
// Verify that all objects have been returned to the pool.
- Assert.assertEquals(0, testBufferPool.getOutstandingObjectCount());
+ Assertions.assertEquals(0, testBufferPool.getOutstandingObjectCount());
});
return testBufferPool;
}
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java
index 3f039814c0f..2593f3d579e 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java
@@ -28,9 +28,9 @@ import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
public class DruidAvaticaDriverTest
{
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
index af52f4feb57..ad09ff1fb4f 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java
@@ -52,7 +52,7 @@ import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import static org.junit.Assume.assumeFalse;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
public class DruidQuidemCommandHandler implements CommandHandler
{
@@ -357,7 +357,7 @@ public class DruidQuidemCommandHandler implements CommandHandler
try {
Injector injector = DruidConnectionExtras.unwrapOrThrow(context.connection()).getInjector();
SqlTestFrameworkConfig cfg = injector.getInstance(SqlTestFrameworkConfig.class);
- assumeFalse(message, cfg.componentSupplier.getSimpleName().equals(supplierName));
+ assumeFalse(cfg.componentSupplier.getSimpleName().equals(supplierName), message);
}
catch (Exception e) {
// This is packaged as an Error because Quidem grabs anything else and pushes it into the output file
diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
index 4f5e03885aa..7da83f33180 100644
--- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
+++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java
@@ -40,11 +40,11 @@ import org.apache.druid.java.util.common.StringUtils;
import org.apache.druid.sql.calcite.MultiComponentSupplier;
import org.apache.druid.sql.calcite.SqlTestFrameworkConfig;
import org.apache.druid.sql.calcite.util.SqlTestFramework.QueryComponentSupplier;
-import org.junit.AssumptionViolatedException;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
+import org.opentest4j.TestAbortedException;
import java.io.File;
import java.io.FileNotFoundException;
@@ -323,10 +323,10 @@ public abstract class DruidQuidemTestBase
druidQuidemRunner.run(inFile, outFile, testConfig.componentSupplierName);
}
catch (Error e) {
- // This catch is needed to workaround the way Quidem currently handles AssumptionViolatedException
+ // This catch is needed to workaround the way Quidem currently handles TestAbortedException
Throwable cause = e.getCause();
- if (cause != null && cause instanceof AssumptionViolatedException) {
- AssumptionViolatedException assumptionViolatedException = (AssumptionViolatedException) cause;
+ if (cause != null && cause instanceof TestAbortedException) {
+ TestAbortedException assumptionViolatedException = (TestAbortedException) cause;
throw assumptionViolatedException;
}
throw e;
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java b/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java
index 74d5439fcec..59b8c77860f 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java
@@ -22,9 +22,9 @@ package org.apache.druid.sql;
import com.google.common.collect.ImmutableList;
import org.apache.druid.server.security.ResourceAction;
import org.apache.druid.sql.SqlLifecycleManager.Cancelable;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import java.util.Collections;
import java.util.List;
@@ -34,7 +34,7 @@ public class SqlLifecycleManagerTest
{
private SqlLifecycleManager lifecycleManager;
- @Before
+ @BeforeEach
public void setup()
{
lifecycleManager = new SqlLifecycleManager();
@@ -46,7 +46,7 @@ public class SqlLifecycleManagerTest
final String sqlId = "sqlId";
Cancelable lifecycle = mockLifecycle();
lifecycleManager.add(sqlId, lifecycle);
- Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
}
@Test
@@ -55,9 +55,9 @@ public class SqlLifecycleManagerTest
final String sqlId = "sqlId";
Cancelable lifecycle = mockLifecycle();
lifecycleManager.add(sqlId, lifecycle);
- Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
lifecycleManager.remove(sqlId, lifecycle);
- Assert.assertEquals(ImmutableList.of(), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(), lifecycleManager.getAll(sqlId));
}
@Test
@@ -66,9 +66,9 @@ public class SqlLifecycleManagerTest
final String sqlId = "sqlId";
Cancelable lifecycle = mockLifecycle();
lifecycleManager.add(sqlId, lifecycle);
- Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
lifecycleManager.remove("invalid", lifecycle);
- Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
}
@Test
@@ -77,9 +77,9 @@ public class SqlLifecycleManagerTest
final String sqlId = "sqlId";
Cancelable lifecycle = mockLifecycle();
lifecycleManager.add(sqlId, lifecycle);
- Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
lifecycleManager.remove(sqlId, mockLifecycle());
- Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId));
}
@Test
@@ -92,9 +92,9 @@ public class SqlLifecycleManagerTest
mockLifecycle()
);
lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle));
- Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
lifecycleManager.removeAll(sqlId, ImmutableList.of(lifecycles.get(0), lifecycles.get(1)));
- Assert.assertEquals(ImmutableList.of(lifecycles.get(2)), lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(ImmutableList.of(lifecycles.get(2)), lifecycleManager.getAll(sqlId));
}
@Test
@@ -107,9 +107,9 @@ public class SqlLifecycleManagerTest
mockLifecycle()
);
lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle));
- Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
lifecycleManager.removeAll("invalid", ImmutableList.of(lifecycles.get(0), lifecycles.get(1)));
- Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
+ Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId));
}
@Test
@@ -124,8 +124,8 @@ public class SqlLifecycleManagerTest
lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle));
final List<Cancelable> lifecyclesFromGetAll = lifecycleManager.getAll(sqlId);
lifecycleManager.removeAll(sqlId, lifecyclesFromGetAll);
- Assert.assertEquals(lifecycles, lifecyclesFromGetAll);
- Assert.assertTrue(lifecycleManager.getAll(sqlId).isEmpty());
+ Assertions.assertEquals(lifecycles, lifecyclesFromGetAll);
+ Assertions.assertTrue(lifecycleManager.getAll(sqlId).isEmpty());
}
private static Cancelable mockLifecycle()
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java b/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java
index 1c793b9ef55..252460f65fe 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java
@@ -23,8 +23,8 @@ import org.apache.druid.error.DruidException;
import org.apache.druid.error.DruidExceptionMatcher;
import org.apache.druid.sql.calcite.util.CalciteTests;
import org.hamcrest.MatcherAssert;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.Map;
@@ -34,7 +34,7 @@ public class SqlQueryPlusTest
public void testSyntaxError()
{
// SqlQueryPlus throws parse errors on build() if the statement is invalid
- final DruidException e = Assert.assertThrows(
+ final DruidException e = Assertions.assertThrows(
DruidException.class,
() -> SqlQueryPlus.builder("SELECT COUNT(*) AS cnt, 'foo' AS")
.auth(CalciteTests.REGULAR_USER_AUTH_RESULT)
@@ -59,7 +59,7 @@ public class SqlQueryPlusTest
.buildJdbc();
// It does throw exceptions on freshCopy(), though.
- final DruidException e = Assert.assertThrows(
+ final DruidException e = Assertions.assertThrows(
DruidException.class,
sqlQueryPlus::freshCopy
);
@@ -83,24 +83,24 @@ public class SqlQueryPlusTest
.queryContext(userProvidedContext)
.auth(CalciteTests.REGULAR_USER_AUTH_RESULT);
- Assert.assertEquals(
+ Assertions.assertEquals(
Map.of("key", "user-provided-value", "key2", "system-default2"),
sqlQueryPlusBuilder.build().context()
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Map.of("key", "user-provided-value", "key2", "system-default2"),
sqlQueryPlusBuilder.buildJdbc().context()
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Map.of("key", "user-provided-value", "key2", "system-default2"),
sqlQueryPlusBuilder.build().withContext(systemDefaultContext, userProvidedContext).context()
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Map.of("key", "system-default", "key2", "system-default2"),
sqlQueryPlusBuilder.build().withContext(systemDefaultContext, Map.of()).context()
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Map.of("key", "user-provided-value"),
sqlQueryPlusBuilder.build().withContext(Map.of(), userProvidedContext).context()
);
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java b/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java
index 5286df34d6b..bb024463665 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java
@@ -32,7 +32,7 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.format.ISODateTimeFormat;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -84,7 +84,7 @@ public class SqlRowTransformerTest extends CalciteTestBase
expectedRow[2],
null
};
- Assert.assertArrayEquals(
+ Assertions.assertArrayEquals(
expectedRow,
IntStream.range(0, expectedRow.length).mapToObj(i -> transformer.transform(row, i)).toArray()
);
@@ -112,7 +112,7 @@ public class SqlRowTransformerTest extends CalciteTestBase
expectedRow[2],
null
};
- Assert.assertArrayEquals(
+ Assertions.assertArrayEquals(
expectedRow,
IntStream.range(0, expectedRow.length).mapToObj(i -> transformer.transform(row, i)).toArray()
);
@@ -126,7 +126,7 @@ public class SqlRowTransformerTest extends CalciteTestBase
rowType
);
- Assert.assertEquals(
+ Assertions.assertEquals(
rowType.getFieldList().stream().map(RelDataTypeField::getName).collect(Collectors.toList()),
transformer.getFieldList()
);
diff --git a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
index 8856a19331f..d17b72f6d98 100644
--- a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java
@@ -65,16 +65,17 @@ import org.apache.druid.sql.calcite.util.CalciteTests;
import org.apache.druid.sql.hook.DruidHookDispatcher;
import org.easymock.EasyMock;
import org.hamcrest.MatcherAssert;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
import javax.servlet.http.HttpServletRequest;
+
+import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
@@ -82,19 +83,19 @@ import java.util.Map;
import java.util.concurrent.TimeUnit;
import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.assertResultsEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
public class SqlStatementTest
{
private static QueryRunnerFactoryConglomerate conglomerate;
private static SpecificSegmentsQuerySegmentWalker walker;
private static Closer resourceCloser;
- @ClassRule
- public static TemporaryFolder temporaryFolder = new TemporaryFolder();
+ @TempDir
+ public static File temporaryFolder;
private ListeningExecutorService executorService;
private final DefaultQueryConfig defaultQueryConfig = new DefaultQueryConfig(
ImmutableMap.of("DEFAULT_KEY", "DEFAULT_VALUE"));
@@ -102,8 +103,8 @@ public class SqlStatementTest
private PolicyEnforcer policyEnforcer;
private SqlStatementFactory sqlStatementFactory;
- @BeforeClass
- public static void setUpClass() throws Exception
+ @BeforeAll
+ public static void setUpClass()
{
resourceCloser = Closer.create();
conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(resourceCloser);
@@ -125,17 +126,17 @@ public class SqlStatementTest
}
};
- walker = CalciteTests.createMockWalker(conglomerate, temporaryFolder.newFolder(), scheduler);
+ walker = CalciteTests.createMockWalker(conglomerate, temporaryFolder, scheduler);
resourceCloser.register(walker);
}
- @AfterClass
+ @AfterAll
public static void tearDownClass() throws IOException
{
resourceCloser.close();
}
- @Before
+ @BeforeEach
public void setUp()
{
executorService = MoreExecutors.listeningDecorator(Execs.multiThreaded(8, "test_sql_resource_%s"));
@@ -144,7 +145,7 @@ public class SqlStatementTest
this.sqlStatementFactory = buildSqlStatementFactory();
}
- @After
+ @AfterEach
public void tearDown() throws Exception
{
executorService.shutdownNow();
@@ -254,11 +255,11 @@ public class SqlStatementTest
);
DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq);
ResultSet resultSet = stmt.plan();
- DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run());
+ DruidException e = Assertions.assertThrows(DruidException.class, () -> resultSet.run());
- Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
- Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
- Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+ Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+ Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+ Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
}
@Test
@@ -390,11 +391,11 @@ public class SqlStatementTest
request(true)
);
ResultSet resultSet = stmt.plan();
- DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run());
+ DruidException e = Assertions.assertThrows(DruidException.class, () -> resultSet.run());
- Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
- Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
- Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+ Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+ Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+ Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
}
@Test
@@ -495,11 +496,11 @@ public class SqlStatementTest
CalciteTests.REGULAR_USER_AUTH_RESULT
);
PreparedStatement stmt = sqlStatementFactory.preparedStatement(sqlReq);
- DruidException e = Assert.assertThrows(DruidException.class, () -> stmt.execute(Collections.emptyList(), null).execute());
+ DruidException e = Assertions.assertThrows(DruidException.class, () -> stmt.execute(Collections.emptyList(), null).execute());
- Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
- Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
- Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
+ Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory());
+ Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona());
+ Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage());
}
@Test
@@ -532,7 +533,7 @@ public class SqlStatementTest
DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq);
Map<String, Object> context = stmt.context();
// should contain only query id, not bySegment since it is not valid for SQL
- Assert.assertEquals(Collections.singleton(QueryContexts.CTX_SQL_QUERY_ID), context.keySet());
+ Assertions.assertEquals(Collections.singleton(QueryContexts.CTX_SQL_QUERY_ID), context.keySet());
}
private SqlStatementFactory buildSqlStatementFactory()
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java
index 1918736af32..ec1554c3f25 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java
@@ -32,22 +32,21 @@ import org.apache.druid.jackson.JacksonModule;
import org.apache.druid.java.util.metrics.Monitor;
import org.apache.druid.server.DruidNode;
import org.easymock.EasyMock;
-import org.easymock.EasyMockRunner;
+import org.easymock.EasyMockExtension;
import org.easymock.Mock;
import org.eclipse.jetty.server.Handler;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import javax.validation.Validation;
import javax.validation.Validator;
+
import java.util.Properties;
import java.util.Set;
-@RunWith(EasyMockRunner.class)
+@ExtendWith(EasyMockExtension.class)
public class AvaticaModuleTest
{
private static final String HOST_AND_PORT = "HOST_AND_PORT";
@@ -57,13 +56,10 @@ public class AvaticaModuleTest
@Mock
private DruidMeta druidMeta;
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
-
private AvaticaModule target;
private Injector injector;
- @Before
+ @BeforeEach
public void setUp()
{
EasyMock.expect(druidNode.getHostAndPortToUse()).andStubReturn(HOST_AND_PORT);
@@ -85,9 +81,9 @@ public class AvaticaModuleTest
public void testAvaticaMonitorIsInjectedAsSingleton()
{
AvaticaMonitor monitor = injector.getInstance(AvaticaMonitor.class);
- Assert.assertNotNull(monitor);
+ Assertions.assertNotNull(monitor);
AvaticaMonitor other = injector.getInstance(AvaticaMonitor.class);
- Assert.assertSame(monitor, other);
+ Assertions.assertSame(monitor, other);
}
@Test
@@ -95,22 +91,22 @@ public class AvaticaModuleTest
{
Set<Class<? extends Monitor>> monitors =
injector.getInstance(Key.get(new TypeLiteral<>() {}));
- Assert.assertTrue(monitors.contains(AvaticaMonitor.class));
+ Assertions.assertTrue(monitors.contains(AvaticaMonitor.class));
}
@Test
public void testAvaticaServerConfigIsInjectable()
{
AvaticaServerConfig config = injector.getInstance(AvaticaServerConfig.class);
- Assert.assertNotNull(config);
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
- Assert.assertEquals(
+ Assertions.assertNotNull(config);
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
+ Assertions.assertEquals(
AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION,
config.getMaxStatementsPerConnection()
);
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_MIN_ROWS_PER_FRAME, config.getMinRowsPerFrame());
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_ROWS_PER_FRAME, config.getMaxRowsPerFrame());
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MIN_ROWS_PER_FRAME, config.getMinRowsPerFrame());
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_ROWS_PER_FRAME, config.getMaxRowsPerFrame());
}
@Test
@@ -125,15 +121,15 @@ public class AvaticaModuleTest
properties.setProperty("druid.sql.avatica.minRowsPerFrame", "10000");
provider.inject(properties, injector.getInstance(JsonConfigurator.class));
final AvaticaServerConfig config = provider.get();
- Assert.assertNotNull(config);
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
- Assert.assertEquals(
+ Assertions.assertNotNull(config);
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
+ Assertions.assertEquals(
AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION,
config.getMaxStatementsPerConnection()
);
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
- Assert.assertEquals(10_000, config.getMinRowsPerFrame());
- Assert.assertEquals(50_000, config.getMaxRowsPerFrame());
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
+ Assertions.assertEquals(10_000, config.getMinRowsPerFrame());
+ Assertions.assertEquals(50_000, config.getMaxRowsPerFrame());
}
@Test
@@ -147,22 +143,20 @@ public class AvaticaModuleTest
properties.setProperty("druid.sql.avatica.maxRowsPerFrame", "50");
provider.inject(properties, injector.getInstance(JsonConfigurator.class));
final AvaticaServerConfig config = provider.get();
- Assert.assertNotNull(config);
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
- Assert.assertEquals(
+ Assertions.assertNotNull(config);
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections());
+ Assertions.assertEquals(
AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION,
config.getMaxStatementsPerConnection()
);
- Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
- Assert.assertEquals(50, config.getMinRowsPerFrame());
- Assert.assertEquals(50, config.getMaxRowsPerFrame());
+ Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout());
+ Assertions.assertEquals(50, config.getMinRowsPerFrame());
+ Assertions.assertEquals(50, config.getMaxRowsPerFrame());
}
@Test
public void testAvaticaServerConfigPropertiesBadMinRowsPerFrame()
{
- expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("'druid.sql.avatica.minRowsPerFrame' must be set to a value greater than 0");
Properties properties = new Properties();
final JsonConfigProvider<AvaticaServerConfig> provider = JsonConfigProvider.of(
"druid.sql.avatica",
@@ -171,26 +165,32 @@ public class AvaticaModuleTest
properties.setProperty("druid.sql.avatica.minRowsPerFrame", "-1");
provider.inject(properties, injector.getInstance(JsonConfigurator.class));
final AvaticaServerConfig config = provider.get();
- Assert.assertNotNull(config);
- config.getMinRowsPerFrame();
+ Assertions.assertNotNull(config);
+ final IllegalArgumentException e = Assertions.assertThrows(
+ IllegalArgumentException.class,
+ config::getMinRowsPerFrame
+ );
+ Assertions.assertTrue(
+ e.getMessage().contains("'druid.sql.avatica.minRowsPerFrame' must be set to a value greater than 0")
+ );
}
@Test
public void testDruidAvaticaJsonHandlerIsInjected()
{
DruidAvaticaJsonHandler handler = injector.getInstance(DruidAvaticaJsonHandler.class);
- Assert.assertNotNull(handler);
+ Assertions.assertNotNull(handler);
DruidAvaticaJsonHandler other = injector.getInstance(DruidAvaticaJsonHandler.class);
- Assert.assertNotSame(handler, other);
+ Assertions.assertNotSame(handler, other);
}
@Test
public void testDruidAvaticaProtobufHandlerIsInjected()
{
DruidAvaticaProtobufHandler handler = injector.getInstance(DruidAvaticaProtobufHandler.class);
- Assert.assertNotNull(handler);
+ Assertions.assertNotNull(handler);
DruidAvaticaProtobufHandler other = injector.getInstance(DruidAvaticaProtobufHandler.class);
- Assert.assertNotSame(handler, other);
+ Assertions.assertNotSame(handler, other);
}
@Test
@@ -198,13 +198,13 @@ public class AvaticaModuleTest
{
Set<Handler> handlers =
injector.getInstance(Key.get(new TypeLiteral<>() {}));
- Assert.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaJsonHandler.class.equals(h.getClass())));
+ Assertions.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaJsonHandler.class.equals(h.getClass())));
}
@Test
public void testDruidAvaticaProtobufHandlerIsRegisterdWithJerseyModule()
{
Set<Handler> handlers = injector.getInstance(Key.get(new TypeLiteral<>() {}));
- Assert.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaProtobufHandler.class.equals(h.getClass())));
+ Assertions.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaProtobufHandler.class.equals(h.getClass())));
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
index 416f04624c1..1c0a68aa86a 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java
@@ -99,9 +99,9 @@ import org.apache.druid.sql.hook.DruidHookDispatcher;
import org.eclipse.jetty.server.Server;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
-import org.junit.Assert;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -361,7 +361,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (Statement stmt = client.createStatement()) {
final ResultSet resultSet = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo;");
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 6L)
),
@@ -377,10 +377,10 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
propertiesSetForbiddenKey.setProperty("user", "regularUserLA");
propertiesSetForbiddenKey.setProperty("forbidden-key", "val");
try (Statement stmt = DriverManager.getConnection(server.url, propertiesSetForbiddenKey).createStatement()) {
- AvaticaSqlException e = Assert.assertThrows(AvaticaSqlException.class, () -> {
+ AvaticaSqlException e = Assertions.assertThrows(AvaticaSqlException.class, () -> {
stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
});
- Assert.assertTrue(e.getMessage().contains("Remote driver error: Unauthorized"));
+ Assertions.assertTrue(e.getMessage().contains("Remote driver error: Unauthorized"));
}
}
@@ -390,7 +390,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (Statement stmt = clientNoTrailingSlash.createStatement()) {
final ResultSet resultSet = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 6L)
),
@@ -405,7 +405,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (PreparedStatement stmt = client.prepareStatement("SELECT COUNT(*) AS cnt FROM druid.foo")) {
final ResultSet resultSet = stmt.executeQuery();
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 6L)
),
@@ -422,7 +422,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
"SELECT __time, CAST(__time AS DATE) AS t2 FROM druid.foo LIMIT 1"
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of(
"__time", new Timestamp(DateTimes.of("2000-01-01T00:00:00.000Z").getMillis()),
@@ -447,7 +447,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
final List<Map<String, Object>> resultRows = getRows(resultSet);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of(
"__time", new Timestamp(Calcites.jodaToCalciteTimestamp(localDateTime, timeZone)),
@@ -467,7 +467,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
"SELECT dim2 AS \"x\", dim2 AS \"y\" FROM druid.foo LIMIT 1"
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("x", "a", "y", "a")
),
@@ -484,7 +484,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
"SELECT dim2, dim2 IS NULL AS isnull FROM druid.foo LIMIT 1"
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("dim2", "a", "isnull", false)
),
@@ -501,7 +501,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
"EXPLAIN PLAN FOR SELECT COUNT(*) AS cnt FROM druid.foo"
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of(
"PLAN",
@@ -524,7 +524,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testDatabaseMetaDataCatalogs() throws SQLException
{
final DatabaseMetaData metaData = client.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(Pair.of("TABLE_CAT", "druid"))
),
@@ -536,7 +536,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testDatabaseMetaDataSchemas() throws SQLException
{
final DatabaseMetaData metaData = client.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(Pair.of("TABLE_CATALOG", "druid"), Pair.of("TABLE_SCHEM", "druid"))
),
@@ -548,7 +548,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testDatabaseMetaDataTables() throws SQLException
{
final DatabaseMetaData metaData = client.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_CAT", "druid"),
@@ -653,7 +653,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testDatabaseMetaDataTablesAsSuperuser() throws SQLException
{
final DatabaseMetaData metaData = superuserClient.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_CAT", "druid"),
@@ -763,7 +763,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testDatabaseMetaDataColumns() throws SQLException
{
final DatabaseMetaData metaData = client.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_SCHEM", "druid"),
@@ -841,7 +841,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testDatabaseMetaDataColumnsOnForbiddenDatasource() throws SQLException
{
final DatabaseMetaData metaData = client.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(),
getRows(
metaData.getColumns(null, "dr_id", CalciteTests.FORBIDDEN_DATASOURCE, null),
@@ -854,7 +854,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testDatabaseMetaDataColumnsWithSuperuser() throws SQLException
{
final DatabaseMetaData metaData = superuserClient.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_SCHEM", "druid"),
@@ -956,7 +956,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
throw new RE(e);
}
for (int i = 0; i < 2000; i++) {
- Assert.assertEquals(i + 6, (int) integers.get(i));
+ Assertions.assertEquals(i + 6, (int) integers.get(i));
}
exec.shutdown();
}
@@ -970,11 +970,11 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
client.createStatement();
}
- AvaticaClientRuntimeException ex = Assert.assertThrows(
+ AvaticaClientRuntimeException ex = Assertions.assertThrows(
AvaticaClientRuntimeException.class,
() -> client.createStatement()
);
- Assert.assertTrue(ex.getMessage().contains("Too many open statements, limit is 4"));
+ Assertions.assertTrue(ex.getMessage().contains("Too many open statements, limit is 4"));
}
@Test
@@ -1000,7 +1000,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
final ResultSet resultSet = statement.executeQuery(
"SELECT COUNT(*) AS cnt FROM druid.foo"
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 6L)
),
@@ -1020,14 +1020,14 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (Statement statement = client.createStatement()) {
try {
statement.executeQuery("SELECT SUM(nonexistent) FROM druid.foo");
- Assert.fail();
+ Assertions.fail();
}
catch (Exception e) {
// Expected
}
final ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(ImmutableMap.of("cnt", 6L)),
getRows(resultSet)
);
@@ -1044,7 +1044,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
for (int i = 0; i < 50; i++) {
try (final Statement statement = client.createStatement()) {
statement.executeQuery("SELECT SUM(nonexistent) FROM druid.foo");
- Assert.fail();
+ Assertions.fail();
}
catch (Exception e) {
// Expected
@@ -1058,7 +1058,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
for (int i = 0; i < 50; i++) {
try (final Statement statement = client.createStatement()) {
final ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(ImmutableMap.of("cnt", 6L)),
getRows(resultSet)
);
@@ -1080,11 +1080,11 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
// codeql[java/database-resource-leak]
clientNoTrailingSlash.createStatement();
- AvaticaClientRuntimeException ex = Assert.assertThrows(
+ AvaticaClientRuntimeException ex = Assertions.assertThrows(
AvaticaClientRuntimeException.class,
() -> server.getUserConnection()
);
- Assert.assertTrue(ex.getMessage().contains("Too many connections"));
+ Assertions.assertTrue(ex.getMessage().contains("Too many connections"));
}
@Test
@@ -1111,7 +1111,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
final ResultSet resultSet = statement.executeQuery(
"SELECT COUNT(*) AS cnt FROM druid.foo"
);
- Assert.assertTrue(resultSet.next());
+ Assertions.assertTrue(resultSet.next());
}
}
}
@@ -1178,8 +1178,8 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
final Statement statement = smallFrameClient.createStatement();
final ResultSet resultSet = statement.executeQuery("SELECT dim1 FROM druid.foo")) {
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(2, frames.size());
- Assert.assertEquals(
+ Assertions.assertEquals(2, frames.size());
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("dim1", ""),
ImmutableMap.of("dim1", "10.1"),
@@ -1225,7 +1225,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
) throws NoSuchStatementException, MissingResultsException
{
// overriding fetch allows us to track how many frames are processed after the first frame, and also fetch size
- Assert.assertEquals(config.minRowsPerFrame, fetchMaxRowCount);
+ Assertions.assertEquals(config.minRowsPerFrame, fetchMaxRowCount);
Frame frame = super.fetch(statement, offset, fetchMaxRowCount);
frames.add(frame);
return frame;
@@ -1241,8 +1241,8 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (final ResultSet resultSet = statement.executeQuery()) {
final List<Map<String, Object>> rows = getRows(resultSet);
// expect minimum threshold to be used, which should be enough to do this all in first fetch
- Assert.assertEquals(0, frames.size());
- Assert.assertEquals(
+ Assertions.assertEquals(0, frames.size());
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("dim1", ""),
ImmutableMap.of("dim1", "10.1"),
@@ -1270,48 +1270,48 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
}
}
- Assert.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) {
final Map<String, Object> stats = logLine.getQueryStats().getStats();
- Assert.assertEquals(true, stats.get("success"));
- Assert.assertEquals("regularUser", stats.get("identity"));
- Assert.assertTrue(stats.containsKey("sqlQuery/time"));
- Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
- Assert.assertTrue(stats.containsKey("sqlQuery/bytes"));
+ Assertions.assertEquals(true, stats.get("success"));
+ Assertions.assertEquals("regularUser", stats.get("identity"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/time"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/bytes"));
}
// invalid sql
testRequestLogger.clear();
try (Statement stmt = client.createStatement()) {
stmt.executeQuery("SELECT notexist FROM druid.foo");
- Assert.fail("invalid SQL should throw SQLException");
+ Assertions.fail("invalid SQL should throw SQLException");
}
catch (SQLException e) {
// Expected
}
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
{
final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
- Assert.assertEquals(false, stats.get("success"));
- Assert.assertEquals("regularUser", stats.get("identity"));
- Assert.assertTrue(stats.containsKey("exception"));
+ Assertions.assertEquals(false, stats.get("success"));
+ Assertions.assertEquals("regularUser", stats.get("identity"));
+ Assertions.assertTrue(stats.containsKey("exception"));
}
// unauthorized sql
testRequestLogger.clear();
try (Statement stmt = client.createStatement()) {
stmt.executeQuery("SELECT count(*) FROM druid.forbiddenDatasource");
- Assert.fail("unauthorzed SQL should throw SQLException");
+ Assertions.fail("unauthorzed SQL should throw SQLException");
}
catch (SQLException e) {
// Expected
}
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
{
final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
- Assert.assertEquals(false, stats.get("success"));
- Assert.assertEquals("regularUser", stats.get("identity"));
- Assert.assertTrue(stats.containsKey("exception"));
+ Assertions.assertEquals(false, stats.get("success"));
+ Assertions.assertEquals("regularUser", stats.get("identity"));
+ Assertions.assertTrue(stats.containsKey("exception"));
}
}
@@ -1325,46 +1325,46 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
stmt.execute();
}
}
- Assert.assertEquals(6, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(6, testRequestLogger.getSqlQueryLogs().size());
for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) {
final Map<String, Object> stats = logLine.getQueryStats().getStats();
- Assert.assertEquals(true, stats.get("success"));
- Assert.assertEquals("regularUser", stats.get("identity"));
- Assert.assertTrue(stats.containsKey("sqlQuery/time"));
- Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
- Assert.assertTrue(stats.containsKey("sqlQuery/bytes"));
+ Assertions.assertEquals(true, stats.get("success"));
+ Assertions.assertEquals("regularUser", stats.get("identity"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/time"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/bytes"));
}
// invalid sql
testRequestLogger.clear();
try (PreparedStatement stmt = client.prepareStatement("SELECT notexist FROM druid.foo")) {
- Assert.fail("invalid SQL should throw SQLException");
+ Assertions.fail("invalid SQL should throw SQLException");
}
catch (SQLException e) {
// Expected
}
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
{
final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
- Assert.assertEquals(false, stats.get("success"));
- Assert.assertEquals("regularUser", stats.get("identity"));
- Assert.assertTrue(stats.containsKey("exception"));
+ Assertions.assertEquals(false, stats.get("success"));
+ Assertions.assertEquals("regularUser", stats.get("identity"));
+ Assertions.assertTrue(stats.containsKey("exception"));
}
// unauthorized sql
testRequestLogger.clear();
try (PreparedStatement stmt = client.prepareStatement("SELECT count(*) FROM druid.forbiddenDatasource")) {
- Assert.fail("unauthorzed SQL should throw SQLException");
+ Assertions.fail("unauthorzed SQL should throw SQLException");
}
catch (SQLException e) {
// Expected
}
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
{
final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
- Assert.assertEquals(false, stats.get("success"));
- Assert.assertEquals("regularUser", stats.get("identity"));
- Assert.assertTrue(stats.containsKey("exception"));
+ Assertions.assertEquals(false, stats.get("success"));
+ Assertions.assertEquals("regularUser", stats.get("identity"));
+ Assertions.assertTrue(stats.containsKey("exception"));
}
}
@@ -1378,14 +1378,14 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
statement.setString(2, "def");
final ResultSet resultSet = statement.executeQuery();
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 2L)
),
rows
);
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
- Assert.assertEquals(
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(
List.of(
new ClientSqlParameter(SqlType.VARCHAR.toString(), "abc"),
new ClientSqlParameter(SqlType.VARCHAR.toString(), "def")
@@ -1402,10 +1402,10 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
client.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) {
statement.setString(1, "dummy");
- Assert.assertThrows(
- "Insufficient permission to view servers",
+ Assertions.assertThrows(
AvaticaSqlException.class,
- statement::executeQuery
+ statement::executeQuery,
+ "Insufficient permission to view servers"
);
}
}
@@ -1416,7 +1416,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (PreparedStatement statement =
superuserClient.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) {
statement.setString(1, "dummy");
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 1L)
),
@@ -1431,19 +1431,19 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (PreparedStatement statement =
superuserClient.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) {
statement.setString(1, "dummy");
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 1L)
),
getRows(statement.executeQuery())
);
statement.setString(1, "foo");
- Assert.assertEquals(
+ Assertions.assertEquals(
Collections.emptyList(),
getRows(statement.executeQuery())
);
statement.setString(1, "dummy");
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 1L)
),
@@ -1460,7 +1460,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
"SELECT COUNT(*) AS cnt FROM druid.lotsocolumns WHERE dimMultivalEnumerated = 'ã…‘ ã…“ ã…• ã…— ã…› ã…œ ã… ã…¡ ã…£'"
);
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 1L)
),
@@ -1473,7 +1473,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
statement.setString(1, "ã…‘ ã…“ ã…• ã…— ã…› ã…œ ã… ã…¡ ã…£");
final ResultSet resultSet2 = statement.executeQuery();
final List<Map<String, Object>> rows = getRows(resultSet2);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 1L)
),
@@ -1531,7 +1531,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
);
// If the escape clause wasn't correctly set, rows for potentially none or more than
// one datasource (some_datasource and somexdatasource) would have been returned
- Assert.assertEquals(
+ Assertions.assertEquals(
someDatasourceColumns,
getRows(
metaData.getColumns(null, "dr_id", CalciteTests.SOME_DATSOURCE_ESCAPED, null),
@@ -1566,7 +1566,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
Pair.of("COLUMN_NAME", "unique_dim1_x")
)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
someXDatasourceColumns,
getRows(
metaData.getColumns(null, "dr_id", "somexdatasource", null),
@@ -1577,7 +1577,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
List<Map<String, Object>> columnsOfBothTables = new ArrayList<>(someDatasourceColumns);
columnsOfBothTables.addAll(someXDatasourceColumns);
// Assert that the pattern matching still works when no escape string is provided
- Assert.assertEquals(
+ Assertions.assertEquals(
columnsOfBothTables,
getRows(
metaData.getColumns(null, "dr_id", "some_datasource", null),
@@ -1586,7 +1586,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
);
// Assert column name pattern works correctly when _ is in the column names
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_SCHEM", "druid"),
@@ -1606,7 +1606,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
);
// Assert column name pattern with % works correctly for column names starting with m
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_SCHEM", "druid"),
@@ -1641,7 +1641,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
{
final DatabaseMetaData metaData = client.getMetaData();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_SCHEM", "druid"),
@@ -1654,7 +1654,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_SCHEM", "druid"),
@@ -1668,7 +1668,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
);
// Assert that some_datasource is treated as a pattern that matches some_datasource and somexdatasource
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
row(
Pair.of("TABLE_SCHEM", "druid"),
@@ -1693,15 +1693,15 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
"SELECT ARRAY_AGG(dim2) AS arr1, ARRAY_AGG(l1) AS arr2, ARRAY_AGG(dbl1) AS arr3, ARRAY_AGG(f1) AS arr4 FROM druid.numfoo")) {
final ResultSet resultSet = statement.executeQuery();
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(1, rows.size());
- Assert.assertTrue(rows.get(0).containsKey("arr1"));
- Assert.assertTrue(rows.get(0).containsKey("arr2"));
- Assert.assertTrue(rows.get(0).containsKey("arr3"));
- Assert.assertTrue(rows.get(0).containsKey("arr4"));
- Assert.assertArrayEquals(new Object[]{"a", null, "", "a", "abc", null}, (Object[]) rows.get(0).get("arr1"));
- Assert.assertArrayEquals(new Object[]{7L, 325323L, 0L, null, null, null}, (Object[]) rows.get(0).get("arr2"));
- Assert.assertArrayEquals(new Object[]{1.0, 1.7, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr3"));
- Assert.assertArrayEquals(new Object[]{1.0, 0.10000000149011612, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr4"));
+ Assertions.assertEquals(1, rows.size());
+ Assertions.assertTrue(rows.get(0).containsKey("arr1"));
+ Assertions.assertTrue(rows.get(0).containsKey("arr2"));
+ Assertions.assertTrue(rows.get(0).containsKey("arr3"));
+ Assertions.assertTrue(rows.get(0).containsKey("arr4"));
+ Assertions.assertArrayEquals(new Object[]{"a", null, "", "a", "abc", null}, (Object[]) rows.get(0).get("arr1"));
+ Assertions.assertArrayEquals(new Object[]{7L, 325323L, 0L, null, null, null}, (Object[]) rows.get(0).get("arr2"));
+ Assertions.assertArrayEquals(new Object[]{1.0, 1.7, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr3"));
+ Assertions.assertArrayEquals(new Object[]{1.0, 0.10000000149011612, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr4"));
}
}
@@ -1718,13 +1718,13 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
statement.executeQuery(query);
}
catch (SQLException e) {
- Assert.assertEquals(
+ Assertions.assertEquals(
e.getMessage(),
expectedError
);
return;
}
- Assert.fail("Test failed, did not get SQLException");
+ Assertions.fail("Test failed, did not get SQLException");
}
private static class TestResultFetcher extends ResultFetcher
@@ -1849,15 +1849,15 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (final Statement statement = conn.createStatement();
final ResultSet resultSet = statement.executeQuery("SELECT dim1 FROM druid.foo")) {
final List<Map<String, Object>> rows = getRows(resultSet);
- Assert.assertEquals(6, rows.size());
- Assert.assertEquals(6, frames.size()); // 3 empty frames and then 3 frames of 2 rows each
-
- Assert.assertFalse(frames.get(0).rows.iterator().hasNext());
- Assert.assertFalse(frames.get(1).rows.iterator().hasNext());
- Assert.assertFalse(frames.get(2).rows.iterator().hasNext());
- Assert.assertTrue(frames.get(3).rows.iterator().hasNext());
- Assert.assertTrue(frames.get(4).rows.iterator().hasNext());
- Assert.assertTrue(frames.get(5).rows.iterator().hasNext());
+ Assertions.assertEquals(6, rows.size());
+ Assertions.assertEquals(6, frames.size()); // 3 empty frames and then 3 frames of 2 rows each
+
+ Assertions.assertFalse(frames.get(0).rows.iterator().hasNext());
+ Assertions.assertFalse(frames.get(1).rows.iterator().hasNext());
+ Assertions.assertFalse(frames.get(2).rows.iterator().hasNext());
+ Assertions.assertTrue(frames.get(3).rows.iterator().hasNext());
+ Assertions.assertTrue(frames.get(4).rows.iterator().hasNext());
+ Assertions.assertTrue(frames.get(5).rows.iterator().hasNext());
}
}
@@ -1872,12 +1872,12 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
public void testMultiStatementFails() throws SQLException
{
try (Statement stmt = client.createStatement()) {
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
AvaticaSqlException.class,
() -> stmt.executeQuery("SET useApproxCountDistinct = true; SELECT COUNT(DISTINCT dim1) AS cnt FROM druid.foo")
);
// ugly error message for statement
- Assert.assertEquals(
+ Assertions.assertEquals(
"Error -1 (00000) : Error while executing SQL \"SET useApproxCountDistinct = true; SELECT COUNT(DISTINCT dim1) AS cnt FROM druid.foo\": Remote driver error: QueryInterruptedException: SQL query string must contain only a single statement -> DruidException: SQL query string must contain only a single statement",
t.getMessage()
);
@@ -1887,12 +1887,12 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
@Test
public void testMultiPreparedStatementFails() throws SQLException
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
AvaticaSqlException.class,
() -> client.prepareStatement("SET vectorize = 'force'; SELECT COUNT(*) AS cnt FROM druid.foo")
);
// sad error message for prepared statement
- Assert.assertEquals(
+ Assertions.assertEquals(
"Error -1 (00000) : while preparing SQL: SET vectorize = 'force'; SELECT COUNT(*) AS cnt FROM druid.foo",
t.getMessage()
);
@@ -1915,11 +1915,11 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
int count = 0;
while (iter.hasNext()) {
Pair<Long, String> row = iter.next();
- Assert.assertNotNull(row.lhs);
- Assert.assertNotNull(row.rhs);
+ Assertions.assertNotNull(row.lhs);
+ Assertions.assertNotNull(row.rhs);
count++;
}
- Assert.assertEquals(6, count);
+ Assertions.assertEquals(6, count);
}
finally {
handle.close();
@@ -1982,16 +1982,16 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo");
}
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
RequestLogLine logLine = testRequestLogger.getSqlQueryLogs().get(0);
String remoteAddress = logLine.getRemoteAddr();
- Assert.assertNotNull("Remote address should not be null", remoteAddress);
+ Assertions.assertNotNull(remoteAddress, "Remote address should not be null");
- Assert.assertTrue(
- "Remote address should be a valid IP address, got: " + remoteAddress,
+ Assertions.assertTrue(
IPV4_PATTERN.matcher(remoteAddress).matches() ||
- IPV6_PATTERN.matcher(remoteAddress).matches()
+ IPV6_PATTERN.matcher(remoteAddress).matches(),
+ "Remote address should be a valid IP address, got: " + remoteAddress
);
}
@@ -2005,18 +2005,18 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
try (Statement stmt = client.createStatement()) {
stmt.executeQuery("SELECT nonexistent FROM druid.foo");
- Assert.fail("Query should have failed");
+ Assertions.fail("Query should have failed");
}
catch (SQLException e) {
// Expected exception
}
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
RequestLogLine logLine = testRequestLogger.getSqlQueryLogs().get(0);
String remoteAddress = logLine.getRemoteAddr();
- Assert.assertNotNull("Remote address should not be null even in failed query", remoteAddress);
- Assert.assertFalse("Remote address should not be empty even in failed query", remoteAddress.length() == 0);
+ Assertions.assertNotNull(remoteAddress, "Remote address should not be null even in failed query");
+ Assertions.assertFalse(remoteAddress.length() == 0, "Remote address should not be empty even in failed query");
}
/**
@@ -2035,20 +2035,20 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase
stmt.executeQuery();
}
- Assert.assertFalse(
- "Should have at least one log entry",
- testRequestLogger.getSqlQueryLogs().isEmpty()
+ Assertions.assertFalse(
+ testRequestLogger.getSqlQueryLogs().isEmpty(),
+ "Should have at least one log entry"
);
for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) {
String remoteAddress = logLine.getRemoteAddr();
- Assert.assertNotNull(
- "Every prepared-statement log entry must carry a remote address",
- remoteAddress
+ Assertions.assertNotNull(
+ remoteAddress,
+ "Every prepared-statement log entry must carry a remote address"
);
- Assert.assertFalse(
- "Every prepared-statement log entry must carry a non-empty remote address",
- remoteAddress.isEmpty()
+ Assertions.assertFalse(
+ remoteAddress.isEmpty(),
+ "Every prepared-statement log entry must carry a non-empty remote address"
);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
index 8746a78f33e..f942c5ecc41 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java
@@ -49,9 +49,9 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
import org.apache.druid.sql.calcite.util.CalciteTests;
import org.apache.druid.sql.calcite.util.QueryFrameworkUtils;
import org.apache.druid.sql.hook.DruidHookDispatcher;
-import org.junit.Assert;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -162,11 +162,11 @@ public class DruidStatementTest extends CalciteTestBase
// First frame, ask for all rows.
statement.execute(queryPlus, -1, null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
subQueryWithOrderByResults(),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
}
}
@@ -182,14 +182,14 @@ public class DruidStatementTest extends CalciteTestBase
// First frame, ask for all rows.
statement.execute(queryPlus, -1, null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
subQueryWithOrderByResults(),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
try {
statement.nextFrame(6, 6);
- Assert.fail();
+ Assertions.fail();
}
catch (Exception e) {
// Expected: can't work with an auto-closed result set.
@@ -206,7 +206,7 @@ public class DruidStatementTest extends CalciteTestBase
try (final DruidJdbcStatement statement = jdbcStatement()) {
// Error: no call to execute;
statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.fail();
+ Assertions.fail();
}
catch (Exception e) {
// Expected
@@ -231,7 +231,7 @@ public class DruidStatementTest extends CalciteTestBase
statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
statement.closeResultSet();
statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.fail();
+ Assertions.fail();
}
catch (Exception e) {
// Expected
@@ -249,20 +249,20 @@ public class DruidStatementTest extends CalciteTestBase
try (final DruidJdbcStatement statement = jdbcStatement()) {
statement.execute(queryPlus, -1, null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
subQueryWithOrderByResults(),
frame
);
// Do it again. JDBC says we can reuse statements sequentially.
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
statement.execute(queryPlus, -1, null);
frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
subQueryWithOrderByResults(),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
}
}
@@ -294,7 +294,7 @@ public class DruidStatementTest extends CalciteTestBase
// First frame, ask for all rows.
statement.execute(queryPlus, -1, null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
Meta.Frame.create(
0,
true,
@@ -315,7 +315,7 @@ public class DruidStatementTest extends CalciteTestBase
),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
}
}
@@ -335,23 +335,23 @@ public class DruidStatementTest extends CalciteTestBase
// First frame, ask for 2 rows.
statement.execute(queryPlus, -1, null);
- Assert.assertEquals(0, statement.getCurrentOffset());
- Assert.assertFalse(statement.isDone());
+ Assertions.assertEquals(0, statement.getCurrentOffset());
+ Assertions.assertFalse(statement.isDone());
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
- Assert.assertEquals(
+ Assertions.assertEquals(
firstFrameResults(),
frame
);
- Assert.assertFalse(statement.isDone());
- Assert.assertEquals(2, statement.getCurrentOffset());
+ Assertions.assertFalse(statement.isDone());
+ Assertions.assertEquals(2, statement.getCurrentOffset());
// Last frame, ask for all remaining rows.
frame = statement.nextFrame(2, 10);
- Assert.assertEquals(
+ Assertions.assertEquals(
secondFrameResults(),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
}
}
@@ -371,28 +371,28 @@ public class DruidStatementTest extends CalciteTestBase
// First frame, ask for 2 rows.
statement.execute(queryPlus, -1, null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
- Assert.assertEquals(
+ Assertions.assertEquals(
firstFrameResults(),
frame
);
- Assert.assertFalse(statement.isDone());
+ Assertions.assertFalse(statement.isDone());
// Do it again. Closes the prior result set.
statement.execute(queryPlus, -1, null);
frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
- Assert.assertEquals(
+ Assertions.assertEquals(
firstFrameResults(),
frame
);
- Assert.assertFalse(statement.isDone());
+ Assertions.assertFalse(statement.isDone());
// Last frame, ask for all remaining rows.
frame = statement.nextFrame(2, 10);
- Assert.assertEquals(
+ Assertions.assertEquals(
secondFrameResults(),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
}
}
@@ -412,11 +412,11 @@ public class DruidStatementTest extends CalciteTestBase
// First frame, ask for 2 rows.
statement.execute(queryPlus, -1, null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2);
- Assert.assertEquals(
+ Assertions.assertEquals(
firstFrameResults(),
frame
);
- Assert.assertFalse(statement.isDone());
+ Assertions.assertFalse(statement.isDone());
// Leave result set open; close statement.
}
@@ -472,10 +472,10 @@ public class DruidStatementTest extends CalciteTestBase
@SuppressWarnings("unchecked")
private void verifySignature(Meta.Signature signature)
{
- Assert.assertEquals(Meta.CursorFactory.ARRAY, signature.cursorFactory);
- Assert.assertEquals(Meta.StatementType.SELECT, signature.statementType);
- Assert.assertEquals(SELECT_STAR_FROM_FOO, signature.sql);
- Assert.assertEquals(
+ Assertions.assertEquals(Meta.CursorFactory.ARRAY, signature.cursorFactory);
+ Assertions.assertEquals(Meta.StatementType.SELECT, signature.statementType);
+ Assertions.assertEquals(SELECT_STAR_FROM_FOO, signature.sql);
+ Assertions.assertEquals(
Lists.newArrayList(
Lists.newArrayList("__time", "TIMESTAMP", "java.math.BigDecimal"),
Lists.newArrayList("dim1", "VARCHAR", "java.lang.String"),
@@ -535,11 +535,11 @@ public class DruidStatementTest extends CalciteTestBase
// First frame, ask for all rows.
statement.execute(Collections.emptyList(), null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
subQueryWithOrderByResults(),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
}
}
@@ -556,20 +556,20 @@ public class DruidStatementTest extends CalciteTestBase
statement.prepare();
statement.execute(Collections.emptyList(), null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
subQueryWithOrderByResults(),
frame
);
// Do it again. JDBC says we can reuse prepared statements sequentially.
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
statement.execute(Collections.emptyList(), null);
frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
subQueryWithOrderByResults(),
frame
);
- Assert.assertTrue(statement.isDone());
+ Assertions.assertTrue(statement.isDone());
}
}
@@ -605,7 +605,7 @@ public class DruidStatementTest extends CalciteTestBase
// Execute many times. First time.
statement.execute(matchingParams, null);
Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
expected,
frame
);
@@ -613,7 +613,7 @@ public class DruidStatementTest extends CalciteTestBase
// Again, same value.
statement.execute(matchingParams, null);
frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
expected,
frame
);
@@ -623,7 +623,7 @@ public class DruidStatementTest extends CalciteTestBase
Collections.singletonList(
TypedValue.ofLocal(ColumnMetaData.Rep.STRING, "foo")), null);
frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6);
- Assert.assertEquals(
+ Assertions.assertEquals(
Meta.Frame.create(0, true, Collections.emptyList()),
frame
);
diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java
index 2efa65d1a7b..274ccd8b750 100644
--- a/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java
@@ -24,8 +24,8 @@ import org.apache.druid.common.exception.AllowedRegexErrorResponseTransformStrat
import org.apache.druid.query.QueryException;
import org.apache.druid.query.QueryInterruptedException;
import org.apache.druid.server.initialization.ServerConfig;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
public class ErrorHandlerTest
@@ -44,7 +44,7 @@ public class ErrorHandlerTest
QueryException input = new QueryException("error", "error message", "error class", "host");
RuntimeException output = errorHandler.sanitize(input);
- Assert.assertNull(output.getMessage());
+ Assertions.assertNull(output.getMessage());
}
@Test
@@ -55,7 +55,7 @@ public class ErrorHandlerTest
QueryInterruptedException input = new QueryInterruptedException("error", "error messagez", "error class", "host");
RuntimeException output = errorHandler.sanitize(input);
- Assert.assertEquals("error messagez", output.getMessage());
+ Assertions.assertEquals("error messagez", output.getMessage());
}
@Test
@@ -68,7 +68,7 @@ public class ErrorHandlerTest
Mockito.when(serverConfig.getErrorResponseTransformStrategy())
.thenReturn(emptyAllowedRegexErrorResponseTransformStrategy);
ErrorHandler errorHandler = new ErrorHandler(serverConfig);
- Assert.assertTrue(errorHandler.hasAffectingErrorResponseTransformStrategy());
+ Assertions.assertTrue(errorHandler.hasAffectingErrorResponseTransformStrategy());
}
@Test
@@ -76,7 +76,7 @@ public class ErrorHandlerTest
{
ServerConfig serverConfig = new ServerConfig();
ErrorHandler errorHandler = new ErrorHandler(serverConfig);
- Assert.assertFalse(errorHandler.hasAffectingErrorResponseTransformStrategy());
+ Assertions.assertFalse(errorHandler.hasAffectingErrorResponseTransformStrategy());
}
@Test
@@ -92,6 +92,6 @@ public class ErrorHandlerTest
Exception input = new Exception("message");
RuntimeException output = errorHandler.sanitize(input);
- Assert.assertEquals(null, output.getMessage());
+ Assertions.assertEquals(null, output.getMessage());
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java
index 790c6eae392..e6750df129a 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java
@@ -25,8 +25,7 @@ import com.google.inject.Key;
import com.google.inject.TypeLiteral;
import org.apache.druid.sql.calcite.aggregation.builtin.CountSqlAggregator;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -35,8 +34,6 @@ import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
-import static org.hamcrest.MatcherAssert.assertThat;
-
public class SqlAggregationModuleTest extends CalciteTestBase
{
private SqlAggregationModule target;
@@ -53,14 +50,14 @@ public class SqlAggregationModuleTest extends CalciteTestBase
public void testDefaultSqlAggregatorsAreBound()
{
Set<SqlAggregator> sqlAggregators = injector.getInstance(Key.get(new TypeLiteral<>() {}));
- Assert.assertNotNull(sqlAggregators);
- Assert.assertEquals(2, sqlAggregators.size());
+ Assertions.assertNotNull(sqlAggregators);
+ Assertions.assertEquals(2, sqlAggregators.size());
final List<SqlAggregator> aggregators = sqlAggregators.stream()
.sorted(Comparator.comparing(o -> o.getClass().getName()))
.collect(Collectors.toList());
- assertThat(aggregators.get(0), CoreMatchers.instanceOf(ApproxCountDistinctSqlAggregator.class));
- assertThat(aggregators.get(1), CoreMatchers.instanceOf(CountSqlAggregator.class));
+ Assertions.assertInstanceOf(ApproxCountDistinctSqlAggregator.class, aggregators.get(0));
+ Assertions.assertInstanceOf(CountSqlAggregator.class, aggregators.get(1));
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java
index d0a25c59df8..b7389bb9eaa 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java
@@ -25,31 +25,29 @@ import org.apache.druid.math.expr.ExpressionType;
import org.apache.druid.math.expr.Parser;
import org.apache.druid.segment.column.ColumnType;
import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.MatcherAssert;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
public class DruidExpressionTest extends InitializedNullHandlingTest
{
@Test
public void test_doubleLiteral_asString()
{
- Assert.assertEquals("0.0", DruidExpression.doubleLiteral(0));
- Assert.assertEquals("-2.0", DruidExpression.doubleLiteral(-2));
- Assert.assertEquals("2.0", DruidExpression.doubleLiteral(2));
- Assert.assertEquals("2.1", DruidExpression.doubleLiteral(2.1));
- Assert.assertEquals("2.12345678", DruidExpression.doubleLiteral(2.12345678));
- Assert.assertEquals("2.2E122", DruidExpression.doubleLiteral(2.2e122));
- Assert.assertEquals("NaN", DruidExpression.doubleLiteral(Double.NaN));
- Assert.assertEquals("Infinity", DruidExpression.doubleLiteral(Double.POSITIVE_INFINITY));
- Assert.assertEquals("-Infinity", DruidExpression.doubleLiteral(Double.NEGATIVE_INFINITY));
+ Assertions.assertEquals("0.0", DruidExpression.doubleLiteral(0));
+ Assertions.assertEquals("-2.0", DruidExpression.doubleLiteral(-2));
+ Assertions.assertEquals("2.0", DruidExpression.doubleLiteral(2));
+ Assertions.assertEquals("2.1", DruidExpression.doubleLiteral(2.1));
+ Assertions.assertEquals("2.12345678", DruidExpression.doubleLiteral(2.12345678));
+ Assertions.assertEquals("2.2E122", DruidExpression.doubleLiteral(2.2e122));
+ Assertions.assertEquals("NaN", DruidExpression.doubleLiteral(Double.NaN));
+ Assertions.assertEquals("Infinity", DruidExpression.doubleLiteral(Double.POSITIVE_INFINITY));
+ Assertions.assertEquals("-Infinity", DruidExpression.doubleLiteral(Double.NEGATIVE_INFINITY));
//CHECKSTYLE.OFF: Regexp
// Min/max double are banned by regexp due to often being inappropriate; but they are appropriate here.
- Assert.assertEquals("4.9E-324", DruidExpression.doubleLiteral(Double.MIN_VALUE));
- Assert.assertEquals("1.7976931348623157E308", DruidExpression.doubleLiteral(Double.MAX_VALUE));
+ Assertions.assertEquals("4.9E-324", DruidExpression.doubleLiteral(Double.MIN_VALUE));
+ Assertions.assertEquals("1.7976931348623157E308", DruidExpression.doubleLiteral(Double.MAX_VALUE));
//CHECKSTYLE.ON: Regexp
- Assert.assertEquals("2.2250738585072014E-308", DruidExpression.doubleLiteral(Double.MIN_NORMAL));
+ Assertions.assertEquals("2.2250738585072014E-308", DruidExpression.doubleLiteral(Double.MIN_NORMAL));
}
@Test
@@ -75,20 +73,20 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
for (double n : doubles) {
final Expr expr = Parser.parse(DruidExpression.doubleLiteral(n), ExprMacroTable.nil());
- Assert.assertTrue(expr.isLiteral());
- MatcherAssert.assertThat(expr.getLiteralValue(), CoreMatchers.instanceOf(Double.class));
- Assert.assertEquals(n, (double) expr.getLiteralValue(), 0d);
+ Assertions.assertTrue(expr.isLiteral());
+ Assertions.assertInstanceOf(Double.class, expr.getLiteralValue());
+ Assertions.assertEquals(n, (double) expr.getLiteralValue(), 0d);
}
}
@Test
public void test_longLiteral_asString()
{
- Assert.assertEquals("0", DruidExpression.longLiteral(0));
- Assert.assertEquals("-2", DruidExpression.longLiteral(-2));
- Assert.assertEquals("2", DruidExpression.longLiteral(2));
- Assert.assertEquals("9223372036854775807", DruidExpression.longLiteral(Long.MAX_VALUE));
- Assert.assertEquals("-9223372036854775808", DruidExpression.longLiteral(Long.MIN_VALUE));
+ Assertions.assertEquals("0", DruidExpression.longLiteral(0));
+ Assertions.assertEquals("-2", DruidExpression.longLiteral(-2));
+ Assertions.assertEquals("2", DruidExpression.longLiteral(2));
+ Assertions.assertEquals("9223372036854775807", DruidExpression.longLiteral(Long.MAX_VALUE));
+ Assertions.assertEquals("-9223372036854775808", DruidExpression.longLiteral(Long.MIN_VALUE));
}
@Test
@@ -104,9 +102,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
for (long n : longs) {
final Expr expr = Parser.parse(DruidExpression.longLiteral(n), ExprMacroTable.nil());
- Assert.assertTrue(expr.isLiteral());
- MatcherAssert.assertThat(expr.getLiteralValue(), CoreMatchers.instanceOf(Number.class));
- Assert.assertEquals(n, ((Number) expr.getLiteralValue()).longValue());
+ Assertions.assertTrue(expr.isLiteral());
+ Assertions.assertInstanceOf(Number.class, expr.getLiteralValue());
+ Assertions.assertEquals(n, ((Number) expr.getLiteralValue()).longValue());
}
}
@@ -115,8 +113,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
{
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, null));
- Assert.assertEquals(ColumnType.STRING, expression.getDruidType());
- Assert.assertEquals("null", expression.getExpression());
+ Assertions.assertEquals(ColumnType.STRING, expression.getDruidType());
+ Assertions.assertEquals("null", expression.getExpression());
}
@Test
@@ -124,8 +122,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
{
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.LONG, null));
- Assert.assertEquals(ColumnType.LONG, expression.getDruidType());
- Assert.assertEquals("null", expression.getExpression());
+ Assertions.assertEquals(ColumnType.LONG, expression.getDruidType());
+ Assertions.assertEquals("null", expression.getExpression());
}
@Test
@@ -133,8 +131,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
{
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, null));
- Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
- Assert.assertEquals("null", expression.getExpression());
+ Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+ Assertions.assertEquals("null", expression.getExpression());
}
@Test
@@ -143,8 +141,8 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
final DruidExpression expression =
DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING_ARRAY, null));
- Assert.assertEquals(ColumnType.STRING_ARRAY, expression.getDruidType());
- Assert.assertEquals("null", expression.getExpression());
+ Assertions.assertEquals(ColumnType.STRING_ARRAY, expression.getDruidType());
+ Assertions.assertEquals("null", expression.getExpression());
}
@Test
@@ -153,9 +151,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
final String s = "abcdé\n \\\" ' \uD83E\uDD20 \txyz";
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, s));
- Assert.assertEquals(ColumnType.STRING, expression.getDruidType());
- Assert.assertEquals("'abcdé\\u000A \\u005C\\u0022 \\u0027 \\uD83E\\uDD20 \\u0009xyz'", expression.getExpression());
- Assert.assertEquals(s, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+ Assertions.assertEquals(ColumnType.STRING, expression.getDruidType());
+ Assertions.assertEquals("'abcdé\\u000A \\u005C\\u0022 \\u0027 \\uD83E\\uDD20 \\u0009xyz'", expression.getExpression());
+ Assertions.assertEquals(s, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
}
@Test
@@ -164,9 +162,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
final String s = "";
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, s));
- Assert.assertEquals(ColumnType.STRING, expression.getDruidType());
- Assert.assertEquals("''", expression.getExpression());
- Assert.assertEquals(
+ Assertions.assertEquals(ColumnType.STRING, expression.getDruidType());
+ Assertions.assertEquals("''", expression.getExpression());
+ Assertions.assertEquals(
s,
Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()
);
@@ -177,9 +175,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
{
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.LONG, -123));
- Assert.assertEquals(ColumnType.LONG, expression.getDruidType());
- Assert.assertEquals("-123", expression.getExpression());
- Assert.assertEquals(-123L, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+ Assertions.assertEquals(ColumnType.LONG, expression.getDruidType());
+ Assertions.assertEquals("-123", expression.getExpression());
+ Assertions.assertEquals(-123L, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
}
@Test
@@ -187,9 +185,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
{
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, -123.4));
- Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
- Assert.assertEquals("-123.4", expression.getExpression());
- Assert.assertEquals(-123.4, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+ Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+ Assertions.assertEquals("-123.4", expression.getExpression());
+ Assertions.assertEquals(-123.4, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
}
@Test
@@ -197,9 +195,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
{
final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.NaN));
- Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
- Assert.assertEquals("NaN", expression.getExpression());
- Assert.assertEquals(Double.NaN, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
+ Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+ Assertions.assertEquals("NaN", expression.getExpression());
+ Assertions.assertEquals(Double.NaN, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue());
}
@Test
@@ -208,9 +206,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
final DruidExpression expression =
DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.NEGATIVE_INFINITY));
- Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
- Assert.assertEquals("-Infinity", expression.getExpression());
- Assert.assertEquals(
+ Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+ Assertions.assertEquals("-Infinity", expression.getExpression());
+ Assertions.assertEquals(
Double.NEGATIVE_INFINITY,
Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()
);
@@ -222,9 +220,9 @@ public class DruidExpressionTest extends InitializedNullHandlingTest
final DruidExpression expression =
DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.POSITIVE_INFINITY));
- Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
- Assert.assertEquals("Infinity", expression.getExpression());
- Assert.assertEquals(
+ Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType());
+ Assertions.assertEquals("Infinity", expression.getExpression());
+ Assertions.assertEquals(
Double.POSITIVE_INFINITY,
Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()
);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
index 7f1ef2400fb..ee7f03e8764 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java
@@ -67,9 +67,10 @@ import org.apache.druid.sql.hook.DruidHookDispatcher;
import org.easymock.EasyMock;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import javax.annotation.Nullable;
+
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;
@@ -334,18 +335,18 @@ public class ExpressionTestHelper
)
{
DruidExpression expression = Expressions.toDruidExpression(PLANNER_CONTEXT, rowSignature, rexNode);
- Assert.assertNotNull(expression);
+ Assertions.assertNotNull(expression);
if (deepCompare) {
- Assert.assertEquals("Expression for: " + rexNode, expectedExpression, expression);
+ Assertions.assertEquals(expectedExpression, expression, "Expression for: " + rexNode);
} else {
- Assert.assertEquals("Expression for: " + rexNode, expectedExpression.getExpression(), expression.getExpression());
+ Assertions.assertEquals(expectedExpression.getExpression(), expression.getExpression(), "Expression for: " + rexNode);
}
ExprEval<?> result = PLANNER_CONTEXT.parseExpression(expression.getExpression())
.eval(expressionBindings);
- Assert.assertEquals("Result for: " + rexNode, expectedResult, result.value());
+ Assertions.assertEquals(expectedResult, result.value(), "Result for: " + rexNode);
}
void testFilter(
@@ -364,7 +365,7 @@ public class ExpressionTestHelper
);
final DimFilter filter = Expressions.toFilter(PLANNER_CONTEXT, rowSignature, virtualColumnRegistry, rexNode);
- Assert.assertEquals("Filter for: " + rexNode, expectedFilter, filter);
+ Assertions.assertEquals(expectedFilter, filter, "Filter for: " + rexNode);
final List<VirtualColumn> virtualColumns =
filter.getRequiredColumns()
@@ -374,12 +375,12 @@ public class ExpressionTestHelper
.sorted(Comparator.comparing(VirtualColumn::getOutputName))
.collect(Collectors.toList());
- Assert.assertEquals(
- "Virtual columns for: " + rexNode,
+ Assertions.assertEquals(
expectedVirtualColumns.stream()
.sorted(Comparator.comparing(VirtualColumn::getOutputName))
.collect(Collectors.toList()),
- virtualColumns
+ virtualColumns,
+ "Virtual columns for: " + rexNode
);
final ValueMatcher matcher = expectedFilter.toFilter().makeMatcher(
@@ -394,6 +395,6 @@ public class ExpressionTestHelper
)
);
- Assert.assertEquals("Result for: " + rexNode, expectedResult, matcher.matches(false));
+ Assertions.assertEquals(expectedResult, matcher.matches(false), "Result for: " + rexNode);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
index fe413defa22..ecb6f4d310c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java
@@ -75,10 +75,9 @@ import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
import org.apache.druid.sql.calcite.planner.PlannerContext;
import org.apache.druid.sql.calcite.rel.CannotBuildQueryException;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.hamcrest.core.StringContains;
import org.joda.time.DateTimeZone;
import org.joda.time.Period;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
@@ -87,8 +86,6 @@ import java.math.BigDecimal;
import java.util.Collections;
import java.util.Map;
-import static org.hamcrest.MatcherAssert.assertThat;
-
public class ExpressionsTest extends CalciteTestBase
{
private static final RowSignature ROW_SIGNATURE = RowSignature
@@ -1280,7 +1277,7 @@ public class ExpressionsTest extends CalciteTestBase
{
final SqlOperator roundFunction = getOperatorConversion(SqlStdOperatorTable.ROUND).calciteOperator();
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
DruidException.class,
() -> testHelper.testExpressionString(
roundFunction,
@@ -1299,7 +1296,7 @@ public class ExpressionsTest extends CalciteTestBase
"IAE Exception"
)
);
- Assert.assertEquals("Function[round] second argument should be a LONG but got STRING instead", t.getMessage());
+ Assertions.assertEquals("Function[round] second argument should be a LONG but got STRING instead", t.getMessage());
}
@Test
@@ -2303,7 +2300,7 @@ public class ExpressionsTest extends CalciteTestBase
@Test
public void testAbnormalRightWithNegativeNumber()
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
DruidException.class,
() -> testHelper.testExpressionString(
new RightOperatorConversion().calciteOperator(),
@@ -2315,7 +2312,7 @@ public class ExpressionsTest extends CalciteTestBase
null
)
);
- Assert.assertEquals("Function[right] needs a positive integer as the second argument", t.getMessage());
+ Assertions.assertEquals("Function[right] needs a positive integer as the second argument", t.getMessage());
}
@Test
@@ -2375,7 +2372,7 @@ public class ExpressionsTest extends CalciteTestBase
@Test
public void testAbnormalLeftWithNegativeNumber()
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
DruidException.class,
() -> testHelper.testExpressionString(
new LeftOperatorConversion().calciteOperator(),
@@ -2387,7 +2384,7 @@ public class ExpressionsTest extends CalciteTestBase
null
)
);
- Assert.assertEquals("Function[left] needs a positive integer as the second argument", t.getMessage());
+ Assertions.assertEquals("Function[left] needs a positive integer as the second argument", t.getMessage());
}
@Test
@@ -2739,12 +2736,12 @@ public class ExpressionsTest extends CalciteTestBase
false
);
- CannotBuildQueryException t = Assert.assertThrows(
+ CannotBuildQueryException t = Assertions.assertThrows(
CannotBuildQueryException.class,
() -> testHelper.testExpression(rexNode, null, plannerContext)
);
- assertThat(t.getMessage(), StringContains.containsString("Unexpected OVER expression"));
+ Assertions.assertTrue(t.getMessage().contains("Unexpected OVER expression"));
}
@Test
@@ -2889,7 +2886,7 @@ public class ExpressionsTest extends CalciteTestBase
)
);
- Assert.assertNull(
+ Assertions.assertNull(
Expressions.calciteLiteralToDruidLiteral(
plannerContext,
rexBuilder.makeCast(
@@ -2910,7 +2907,7 @@ public class ExpressionsTest extends CalciteTestBase
final DruidLiteral actual
)
{
- Assert.assertEquals(
+ Assertions.assertEquals(
StringUtils.format("%s: %s", expected.type(), expected.value()),
StringUtils.format("%s: %s", actual.type(), actual.value())
);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java
index 2bb0116825a..6a15708b072 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java
@@ -26,7 +26,7 @@ import org.apache.druid.segment.column.ColumnType;
import org.apache.druid.segment.column.RowSignature;
import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressMatchOperatorConversion;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -67,7 +67,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
@Test
public void testTooFewArgs()
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Collections.emptyList(),
@@ -75,7 +75,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
}
@Test
@@ -83,7 +83,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
{
String address = IPV4;
String subnet = SUBNET_192_168;
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Arrays.asList(
@@ -95,7 +95,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage());
}
@Test
@@ -103,7 +103,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
{
String address = IPV4;
String variableName = VAR;
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Arrays.asList(
@@ -114,7 +114,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_match] subnet argument must be a literal", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_match] subnet argument must be a literal", t.getMessage());
}
@Test
@@ -122,7 +122,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
{
String address = IPV4;
String invalidSubnet = "192.168.0.1/invalid";
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Arrays.asList(
@@ -133,7 +133,7 @@ public class IPv4AddressMatchExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_match] subnet arg has an invalid format: 192.168.0.1/invalid", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_match] subnet arg has an invalid format: 192.168.0.1/invalid", t.getMessage());
}
@Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java
index 65ea14d8f87..d9f42d23a2d 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java
@@ -26,7 +26,7 @@ import org.apache.druid.segment.column.ColumnType;
import org.apache.druid.segment.column.RowSignature;
import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressParseOperatorConversion;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -58,7 +58,7 @@ public class IPv4AddressParseExpressionTest extends CalciteTestBase
@Test
public void testTooFewArgs()
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Collections.emptyList(),
@@ -66,13 +66,13 @@ public class IPv4AddressParseExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
}
@Test
public void testTooManyArgs()
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Arrays.asList(
@@ -83,7 +83,7 @@ public class IPv4AddressParseExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage());
}
@Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java
index f1844fb940e..a50b92321ad 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java
@@ -26,7 +26,7 @@ import org.apache.druid.segment.column.ColumnType;
import org.apache.druid.segment.column.RowSignature;
import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressStringifyOperatorConversion;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -59,7 +59,7 @@ public class IPv4AddressStringifyExpressionTest extends CalciteTestBase
@Test
public void testTooFewArgs()
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Collections.emptyList(),
@@ -67,13 +67,13 @@ public class IPv4AddressStringifyExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
}
@Test
public void testTooManyArgs()
{
- Throwable t = Assert.assertThrows(
+ Throwable t = Assertions.assertThrows(
ExpressionValidationException.class,
() -> testExpression(
Arrays.asList(
@@ -84,7 +84,7 @@ public class IPv4AddressStringifyExpressionTest extends CalciteTestBase
IGNORE_EXPECTED_RESULT
)
);
- Assert.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
+ Assertions.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage());
}
@Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java
index 20369bfcf05..486e48349b8 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java
@@ -38,10 +38,9 @@ import org.apache.calcite.sql.validate.SqlValidator;
import org.apache.calcite.sql.validate.SqlValidatorScope;
import org.apache.druid.java.util.common.StringUtils;
import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
@@ -51,11 +50,9 @@ import java.util.List;
public class OperatorConversionsTest
{
- public static class DefaultOperandTypeCheckerTest
+ @Nested
+ public class DefaultOperandTypeCheckerTest
{
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
-
@Test
public void testGetOperandCountRange()
{
@@ -67,8 +64,8 @@ public class OperatorConversionsTest
.literalOperands()
.build();
SqlOperandCountRange countRange = typeChecker.getOperandCountRange();
- Assert.assertEquals(2, countRange.getMin());
- Assert.assertEquals(3, countRange.getMax());
+ Assertions.assertEquals(2, countRange.getMin());
+ Assertions.assertEquals(3, countRange.getMax());
}
@Test
@@ -81,9 +78,9 @@ public class OperatorConversionsTest
.requiredOperandCount(2)
.literalOperands()
.build();
- Assert.assertFalse(typeChecker.isOptional(0));
- Assert.assertFalse(typeChecker.isOptional(1));
- Assert.assertTrue(typeChecker.isOptional(2));
+ Assertions.assertFalse(typeChecker.isOptional(0));
+ Assertions.assertFalse(typeChecker.isOptional(1));
+ Assertions.assertTrue(typeChecker.isOptional(2));
}
@Test
@@ -96,7 +93,7 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertTrue(
+ Assertions.assertTrue(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -119,7 +116,7 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertTrue(
+ Assertions.assertTrue(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -141,7 +138,7 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertFalse(
+ Assertions.assertFalse(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -163,14 +160,15 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- expectedException.expect(CalciteContextException.class);
- expectedException.expectMessage("Argument to function 'testLiteralOperandCheckLiteralThrow' must be a literal");
- typeChecker.checkOperandTypes(
- mockCallBinding(
- function,
- ImmutableList.of(new OperandSpec(SqlTypeName.INTEGER, false))
+ assertThrowsWithMessage(
+ () -> typeChecker.checkOperandTypes(
+ mockCallBinding(
+ function,
+ ImmutableList.of(new OperandSpec(SqlTypeName.INTEGER, false))
+ ),
+ true
),
- true
+ "Argument to function 'testLiteralOperandCheckLiteralThrow' must be a literal"
);
}
@@ -184,7 +182,7 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertTrue(
+ Assertions.assertTrue(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -205,7 +203,7 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertTrue(
+ Assertions.assertTrue(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -214,7 +212,7 @@ public class OperatorConversionsTest
true
)
);
- Assert.assertTrue(
+ Assertions.assertTrue(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -235,7 +233,7 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertTrue(
+ Assertions.assertTrue(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -259,7 +257,7 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertTrue(
+ Assertions.assertTrue(
typeChecker.checkOperandTypes(
mockCallBinding(
function,
@@ -289,9 +287,9 @@ public class OperatorConversionsTest
new OperandSpec(SqlTypeName.CHAR, false, true)
)
);
- Assert.assertTrue(typeChecker.checkOperandTypes(binding, true));
+ Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true));
RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding);
- Assert.assertFalse(returnType.isNullable());
+ Assertions.assertFalse(returnType.isNullable());
}
@Test
@@ -310,9 +308,9 @@ public class OperatorConversionsTest
new OperandSpec(SqlTypeName.CHAR, false, true)
)
);
- Assert.assertTrue(typeChecker.checkOperandTypes(binding, true));
+ Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true));
RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding);
- Assert.assertTrue(returnType.isNullable());
+ Assertions.assertTrue(returnType.isNullable());
}
@Test
@@ -331,9 +329,9 @@ public class OperatorConversionsTest
new OperandSpec(SqlTypeName.CHAR, false, false)
)
);
- Assert.assertTrue(typeChecker.checkOperandTypes(binding, true));
+ Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true));
RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding);
- Assert.assertTrue(returnType.isNullable());
+ Assertions.assertTrue(returnType.isNullable());
}
@Test
@@ -346,19 +344,18 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- expectedException.expect(CalciteContextException.class);
- expectedException.expectMessage(
- "Exception in test for operator[testNullForNonNullableOperand]: Illegal use of 'NULL'"
- );
- typeChecker.checkOperandTypes(
- mockCallBinding(
- function,
- ImmutableList.of(
- new OperandSpec(SqlTypeName.NULL, false),
- new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
- )
+ assertThrowsWithMessage(
+ () -> typeChecker.checkOperandTypes(
+ mockCallBinding(
+ function,
+ ImmutableList.of(
+ new OperandSpec(SqlTypeName.NULL, false),
+ new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
+ )
+ ),
+ true
),
- true
+ "Exception in test for operator[testNullForNonNullableOperand]: Illegal use of 'NULL'"
);
}
@@ -372,19 +369,18 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- expectedException.expect(CalciteContextException.class);
- expectedException.expectMessage(
- "Exception in test for operator[testNullLiteralForNonNullableOperand]: Illegal use of 'NULL'"
- );
- typeChecker.checkOperandTypes(
- mockCallBinding(
- function,
- ImmutableList.of(
- new OperandSpec(SqlTypeName.NULL, true),
- new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
- )
+ assertThrowsWithMessage(
+ () -> typeChecker.checkOperandTypes(
+ mockCallBinding(
+ function,
+ ImmutableList.of(
+ new OperandSpec(SqlTypeName.NULL, true),
+ new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
+ )
+ ),
+ true
),
- true
+ "Exception in test for operator[testNullLiteralForNonNullableOperand]: Illegal use of 'NULL'"
);
}
@@ -398,22 +394,27 @@ public class OperatorConversionsTest
.returnTypeNonNull(SqlTypeName.CHAR)
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- expectedException.expect(CalciteContextException.class);
- expectedException.expectMessage(
- "Exception in test for operator[testNonCastableType]: Cannot apply 'testNonCastableType' to arguments of type"
- );
- typeChecker.checkOperandTypes(
- mockCallBinding(
- function,
- ImmutableList.of(
- new OperandSpec(SqlTypeName.INTEGER, true),
- new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
- )
+ assertThrowsWithMessage(
+ () -> typeChecker.checkOperandTypes(
+ mockCallBinding(
+ function,
+ ImmutableList.of(
+ new OperandSpec(SqlTypeName.INTEGER, true),
+ new OperandSpec(SqlTypeName.INTERVAL_HOUR, false)
+ )
+ ),
+ true
),
- true
+ "Exception in test for operator[testNonCastableType]: Cannot apply 'testNonCastableType' to arguments of type"
);
}
+ private static void assertThrowsWithMessage(Runnable runnable, String expectedMessage)
+ {
+ final CalciteContextException e = Assertions.assertThrows(CalciteContextException.class, runnable::run);
+ Assertions.assertTrue(e.getMessage().contains(expectedMessage), e.getMessage());
+ }
+
@Test
public void testSignatureWithNames()
{
@@ -426,7 +427,7 @@ public class OperatorConversionsTest
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertEquals(
+ Assertions.assertEquals(
"'testSignatureWithNames(<x>, [<y>, [<z>]])'",
typeChecker.getAllowedSignatures(function, function.getName())
);
@@ -443,7 +444,7 @@ public class OperatorConversionsTest
.build();
SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker();
- Assert.assertEquals(
+ Assertions.assertEquals(
"'testSignatureWithoutNames(<INTEGER>, [<DATE>, [<ANY>]])'",
typeChecker.getAllowedSignatures(function, function.getName())
);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
index be939fd58ae..45f83af822c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java
@@ -43,8 +43,8 @@ import org.apache.druid.sql.calcite.schema.ViewSchema;
import org.apache.druid.sql.calcite.util.CalciteTests;
import org.apache.druid.sql.hook.DruidHookDispatcher;
import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.Collections;
@@ -93,7 +93,7 @@ public class ExternalTableScanRuleTest
ExternalTableScanRule rule = new ExternalTableScanRule(plannerContext);
rule.matches(EasyMock.createMock(RelOptRuleCall.class));
- Assert.assertEquals(
+ Assertions.assertEquals(
"Cannot use [EXTERN] with SQL engine [native].",
plannerContext.getPlanningError()
);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java
index 6088ffb6454..3c578f9d44a 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java
@@ -30,7 +30,7 @@ import org.junit.jupiter.params.provider.MethodSource;
import java.util.List;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
public class CombineAndSimplifyBoundsTest extends BaseCalciteQueryTest
{
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java
index b88c520e522..d6b52f81563 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java
@@ -27,7 +27,7 @@ import org.apache.druid.segment.column.ColumnHolder;
import org.apache.druid.segment.column.ColumnType;
import org.apache.druid.segment.column.RowSignature;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class FiltrationTest extends CalciteTestBase
@@ -46,12 +46,12 @@ public class FiltrationTest extends CalciteTestBase
null
).optimize(RowSignature.builder().add(ColumnHolder.TIME_COLUMN_NAME, ColumnType.LONG).build());
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(Filtration.eternity()),
filtration.getIntervals()
);
- Assert.assertEquals(
+ Assertions.assertEquals(
new NotDimFilter(
new IntervalDimFilter(
ColumnHolder.TIME_COLUMN_NAME,
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java
index fc62cb05fba..cbe554667b3 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java
@@ -32,7 +32,7 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
import org.apache.druid.sql.http.ResultFormat;
import org.apache.druid.sql.http.SqlParameter;
import org.apache.druid.sql.http.SqlQuery;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class SqlQueryTest extends CalciteTestBase
@@ -51,7 +51,7 @@ public class SqlQueryTest extends CalciteTestBase
ImmutableMap.of("useCache", false),
ImmutableList.of(new SqlParameter(SqlType.INTEGER, 1))
);
- Assert.assertEquals(query, JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(query), SqlQuery.class));
+ Assertions.assertEquals(query, JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(query), SqlQuery.class));
}
@Test
@@ -79,7 +79,7 @@ public class SqlQueryTest extends CalciteTestBase
final SqlQuery observedSqlQuery =
JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(givenClientSqlQuery), SqlQuery.class);
- Assert.assertEquals(expectedSqlQuery, observedSqlQuery);
+ Assertions.assertEquals(expectedSqlQuery, observedSqlQuery);
}
@Test
@@ -107,7 +107,7 @@ public class SqlQueryTest extends CalciteTestBase
final SqlQuery observedSqlQuery =
JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(givenClientSqlQuery), SqlQuery.class);
- Assert.assertEquals(expectedSqlQuery, observedSqlQuery);
+ Assertions.assertEquals(expectedSqlQuery, observedSqlQuery);
}
@Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java
index 651b8f712f7..e9019e6f822 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java
@@ -25,8 +25,8 @@ import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.util.DateString;
import org.apache.calcite.util.TimestampString;
import org.apache.druid.error.DruidException;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
public class DruidSqlParserTest
{
@@ -34,21 +34,21 @@ public class DruidSqlParserTest
public void test_sqlLiteralToContextValue_null()
{
final SqlLiteral literal = SqlLiteral.createNull(SqlParserPos.ZERO);
- Assert.assertNull(DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertNull(DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
public void test_sqlLiteralToContextValue_string()
{
final SqlLiteral literal = SqlLiteral.createCharString("abc", SqlParserPos.ZERO);
- Assert.assertEquals("abc", DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals("abc", DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
public void test_sqlLiteralToContextValue_stringWithSpecialChars()
{
final SqlLiteral literal = SqlLiteral.createCharString("hello\nworld\t\"test\"", SqlParserPos.ZERO);
- Assert.assertEquals("hello\nworld\t\"test\"", DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals("hello\nworld\t\"test\"", DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
@@ -56,14 +56,14 @@ public class DruidSqlParserTest
{
// Numbers within Long range are converted to Long.
final SqlLiteral literal = SqlLiteral.createExactNumeric("42", SqlParserPos.ZERO);
- Assert.assertEquals(42L, DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals(42L, DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
public void test_sqlLiteralToContextValue_negativeInteger()
{
final SqlLiteral literal = SqlLiteral.createExactNumeric("-123", SqlParserPos.ZERO);
- Assert.assertEquals(-123L, DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals(-123L, DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
@@ -71,7 +71,7 @@ public class DruidSqlParserTest
{
// Decimals are converted to Double.
final SqlLiteral literal = SqlLiteral.createExactNumeric("3.14159", SqlParserPos.ZERO);
- Assert.assertEquals(3.14159, DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals(3.14159, DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
@@ -79,28 +79,28 @@ public class DruidSqlParserTest
{
// Integers outside Long range are retained as strings.
final SqlLiteral literal = SqlLiteral.createExactNumeric("123456789012345678901234567890", SqlParserPos.ZERO);
- Assert.assertEquals("123456789012345678901234567890", DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals("123456789012345678901234567890", DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
public void test_sqlLiteralToContextValue_approximateNumeric()
{
final SqlLiteral literal = SqlLiteral.createApproxNumeric("1.23E10", SqlParserPos.ZERO);
- Assert.assertEquals(1.23E10, DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals(1.23E10, DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
public void test_sqlLiteralToContextValue_booleanTrue()
{
final SqlLiteral literal = SqlLiteral.createBoolean(true, SqlParserPos.ZERO);
- Assert.assertEquals(true, DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals(true, DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
public void test_sqlLiteralToContextValue_booleanFalse()
{
final SqlLiteral literal = SqlLiteral.createBoolean(false, SqlParserPos.ZERO);
- Assert.assertEquals(false, DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals(false, DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
@@ -110,7 +110,7 @@ public class DruidSqlParserTest
final TimestampString timestampString = new TimestampString("2023-01-15 14:30:00");
final SqlLiteral literal =
SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, timestampString, 0, SqlParserPos.ZERO);
- Assert.assertEquals("2023-01-15T14:30:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals("2023-01-15T14:30:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
@@ -119,7 +119,7 @@ public class DruidSqlParserTest
final TimestampString timestampString = new TimestampString("2023-01-15 14:30:00.123");
final SqlLiteral literal =
SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, timestampString, 3, SqlParserPos.ZERO);
- Assert.assertEquals("2023-01-15T14:30:00.123Z", DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals("2023-01-15T14:30:00.123Z", DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
@@ -127,29 +127,29 @@ public class DruidSqlParserTest
{
final DateString dateString = new DateString("2023-01-15");
final SqlLiteral literal = SqlLiteral.createDate(dateString, SqlParserPos.ZERO);
- Assert.assertEquals("2023-01-15T00:00:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
+ Assertions.assertEquals("2023-01-15T00:00:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal));
}
@Test
public void test_sqlLiteralToContextValue_unsupportedType()
{
final SqlLiteral literal = SqlLiteral.createSymbol(SqlTypeName.BINARY, SqlParserPos.ZERO);
- final DruidException exception = Assert.assertThrows(
+ final DruidException exception = Assertions.assertThrows(
DruidException.class,
() -> DruidSqlParser.sqlLiteralToContextValue(literal)
);
- Assert.assertTrue(exception.getMessage().contains("Unsupported type for SET"));
+ Assertions.assertTrue(exception.getMessage().contains("Unsupported type for SET"));
}
@Test
public void testParse_reservedKeywordIdentifier()
{
- final DruidException exception = Assert.assertThrows(
+ final DruidException exception = Assertions.assertThrows(
DruidException.class,
() -> DruidSqlParser.parse("SELECT start FROM sys.\"segments\" LIMIT 1", false)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
"Token [start] (line [1], column [8]) is a reserved keyword. "
+ "To use it as an identifier, quote it as [\"start\"]",
exception.getMessage()
@@ -159,35 +159,35 @@ public class DruidSqlParserTest
@Test
public void testParse_reservedKeywordOutsideIdentifierContext()
{
- final DruidException exception = Assert.assertThrows(
+ final DruidException exception = Assertions.assertThrows(
DruidException.class,
() -> DruidSqlParser.parse("SELECT * FROM foo GROUP ORDER BY x", false)
);
- Assert.assertFalse(exception.getMessage().contains("is a reserved keyword"));
+ Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword"));
}
@Test
public void testParse_expectedReservedKeyword()
{
- final DruidException exception = Assert.assertThrows(
+ final DruidException exception = Assertions.assertThrows(
DruidException.class,
() -> DruidSqlParser.parse("SELECT a FROM", false)
);
- Assert.assertFalse(exception.getMessage().contains("is a reserved keyword"));
+ Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword"));
}
@Test
public void testParse_reservedKeywordFunctionCall()
{
// UNNEST is a reserved keyword, but it appears in a function-call context, not as an identifier.
- final DruidException exception = Assert.assertThrows(
+ final DruidException exception = Assertions.assertThrows(
DruidException.class,
() -> DruidSqlParser.parse("SELECT strlen(unnest(a_int))", false)
);
- Assert.assertTrue(exception.getMessage().contains("Received an unexpected token"));
- Assert.assertFalse(exception.getMessage().contains("is a reserved keyword"));
+ Assertions.assertTrue(exception.getMessage().contains("Received an unexpected token"));
+ Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword"));
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
index b51a106aef9..50cf4cfd824 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
@@ -48,10 +48,11 @@ import org.hamcrest.MatcherAssert;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
import java.util.Arrays;
@@ -60,10 +61,11 @@ public class DruidSqlParserUtilsTest
/**
* Sanity checking that the formats of TIME_FLOOR(__time, Period) work as expected
*/
- @RunWith(Parameterized.class)
- public static class TimeFloorToGranularityConversionTest
+ @Nested
+ @ParameterizedClass(name = "{1}")
+ @MethodSource("constructorFeeder")
+ public class TimeFloorToGranularityConversionTest
{
- @Parameterized.Parameters(name = "{1}")
public static Iterable<Object[]> constructorFeeder()
{
return ImmutableList.of(
@@ -71,8 +73,8 @@ public class DruidSqlParserUtilsTest
);
}
- String periodString;
- Granularity expectedGranularity;
+ private final String periodString;
+ private final Granularity expectedGranularity;
public TimeFloorToGranularityConversionTest(String periodString, Granularity expectedGranularity)
{
@@ -85,21 +87,22 @@ public class DruidSqlParserUtilsTest
{
final SqlNodeList args = new SqlNodeList(SqlParserPos.ZERO);
args.add(new SqlIdentifier("__time", SqlParserPos.ZERO));
- args.add(SqlLiteral.createCharString(this.periodString, SqlParserPos.ZERO));
+ args.add(SqlLiteral.createCharString(periodString, SqlParserPos.ZERO));
final SqlNode timeFloorCall = TimeFloorOperatorConversion.SQL_FUNCTION.createCall(args);
Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(
timeFloorCall);
- Assert.assertEquals(expectedGranularity, actualGranularity);
+ Assertions.assertEquals(expectedGranularity, actualGranularity);
}
}
/**
* Sanity checking that FLOOR(__time TO TimeUnit()) works as intended with the supported granularities
*/
- @RunWith(Parameterized.class)
- public static class FloorToGranularityConversionTest
+ @Nested
+ @ParameterizedClass(name = "{1}")
+ @MethodSource("constructorFeeder")
+ public class FloorToGranularityConversionTest
{
- @Parameterized.Parameters(name = "{1}")
public static Iterable<Object[]> constructorFeeder()
{
return ImmutableList.of(
@@ -114,9 +117,9 @@ public class DruidSqlParserUtilsTest
);
}
- TimeUnit timeUnit;
- Period period;
- Granularity expectedGranularity;
+ private final TimeUnit timeUnit;
+ private final Period period;
+ private final Granularity expectedGranularity;
public FloorToGranularityConversionTest(TimeUnit timeUnit, Period period, Granularity expectedGranularity)
{
@@ -131,10 +134,10 @@ public class DruidSqlParserUtilsTest
// parserPos doesn't matter
final SqlNodeList args = new SqlNodeList(SqlParserPos.ZERO);
args.add(new SqlIdentifier("__time", SqlParserPos.ZERO));
- args.add(new SqlIntervalQualifier(this.timeUnit, null, SqlParserPos.ZERO));
+ args.add(new SqlIntervalQualifier(timeUnit, null, SqlParserPos.ZERO));
final SqlNode floorCall = SqlStdOperatorTable.FLOOR.createCall(args);
Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(floorCall);
- Assert.assertEquals(expectedGranularity, actualGranularity);
+ Assertions.assertEquals(expectedGranularity, actualGranularity);
}
/**
@@ -145,7 +148,7 @@ public class DruidSqlParserUtilsTest
{
SqlNode sqlNode = SqlLiteral.createCharString(timeUnit.name(), SqlParserPos.ZERO);
Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode);
- Assert.assertEquals(expectedGranularity, actualGranularity);
+ Assertions.assertEquals(expectedGranularity, actualGranularity);
}
/**
@@ -156,7 +159,7 @@ public class DruidSqlParserUtilsTest
{
SqlNode sqlNode = new SqlIdentifier(period.toString(), SqlParserPos.ZERO);
Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode);
- Assert.assertEquals(expectedGranularity, actualGranularity);
+ Assertions.assertEquals(expectedGranularity, actualGranularity);
}
/**
@@ -167,19 +170,20 @@ public class DruidSqlParserUtilsTest
{
SqlNode sqlNode = SqlLiteral.createCharString(period.toString(), SqlParserPos.ZERO);
Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode);
- Assert.assertEquals(expectedGranularity, actualGranularity);
+ Assertions.assertEquals(expectedGranularity, actualGranularity);
}
}
/**
* Test class that validates the resolution of "CLUSTERED BY" columns to output columns.
*/
- public static class ResolveClusteredByColumnsTest
+ @Nested
+ public class ResolveClusteredByColumnsTest
{
@Test
public void testNullClusteredByAndSource()
{
- Assert.assertNull(DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(null, null));
+ Assertions.assertNull(DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(null, null));
}
@Test
@@ -191,7 +195,7 @@ public class DruidSqlParserUtilsTest
.add(3, "bar")
.build();
- Assert.assertNull(
+ Assertions.assertNull(
DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(
null,
fields
@@ -214,7 +218,7 @@ public class DruidSqlParserUtilsTest
new SqlParserPos(0, 3)
);
args.add(sqlBasicCall1);
- Assert.assertEquals(
+ Assertions.assertEquals(
Arrays.asList("__time", "FOO", "DIM3_ALIAS"),
DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(args, null)
);
@@ -234,7 +238,7 @@ public class DruidSqlParserUtilsTest
clusteredByArgs.add(new SqlIdentifier("FOO", SqlParserPos.ZERO));
clusteredByArgs.add(SqlLiteral.createExactNumeric("3", SqlParserPos.ZERO));
- Assert.assertEquals(
+ Assertions.assertEquals(
Arrays.asList("__time", "FOO", "BOO"),
DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(clusteredByArgs, sourceFieldMappings)
);
@@ -261,14 +265,15 @@ public class DruidSqlParserUtilsTest
clusteredByArgs.add(SqlLiteral.createExactNumeric("5", SqlParserPos.ZERO));
clusteredByArgs.add(SqlLiteral.createExactNumeric("7", SqlParserPos.ZERO));
- Assert.assertEquals(
+ Assertions.assertEquals(
Arrays.asList("DIM3_ALIAS", "floor_dim4_time", "DIM5", "TIME_FLOOR(\"timestamps\", 'PT1H')"),
DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(clusteredByArgs, sourceFieldMappings)
);
}
}
- public static class ClusteredByColumnsValidationTest
+ @Nested
+ public class ClusteredByColumnsValidationTest
{
/**
* Tests an empty CLUSTERED BY clause
@@ -340,7 +345,8 @@ public class DruidSqlParserUtilsTest
}
}
- public static class FloorToGranularityConversionErrorsTest
+ @Nested
+ public class FloorToGranularityConversionErrorsTest
{
/**
* Tests clause like "PARTITIONED BY CEIL(__time TO DAY)"
@@ -453,7 +459,8 @@ public class DruidSqlParserUtilsTest
}
}
- public static class NonParameterizedTests
+ @Nested
+ public class NonParameterizedTests
{
private static final DateTimeZone TZ_LOS_ANGELES = DateTimes.inferTzFromString("America/Los_Angeles");
@@ -472,7 +479,7 @@ public class DruidSqlParserUtilsTest
DateTimeZone.UTC
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
@@ -490,7 +497,7 @@ public class DruidSqlParserUtilsTest
TZ_LOS_ANGELES
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
@@ -508,7 +515,7 @@ public class DruidSqlParserUtilsTest
DateTimeZone.UTC
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
@@ -526,7 +533,7 @@ public class DruidSqlParserUtilsTest
TZ_LOS_ANGELES
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
@@ -543,7 +550,7 @@ public class DruidSqlParserUtilsTest
DateTimeZone.UTC
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
@@ -560,7 +567,7 @@ public class DruidSqlParserUtilsTest
DateTimeZone.UTC
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
@@ -577,7 +584,7 @@ public class DruidSqlParserUtilsTest
TZ_LOS_ANGELES
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
@@ -594,13 +601,13 @@ public class DruidSqlParserUtilsTest
TZ_LOS_ANGELES
);
- Assert.assertEquals(String.valueOf(ts.getMillis()), s);
+ Assertions.assertEquals(String.valueOf(ts.getMillis()), s);
}
@Test
public void test_parseTimeStampWithTimeZone_unknownTimestamp_invalid()
{
- final DruidException e = Assert.assertThrows(
+ final DruidException e = Assertions.assertThrows(
DruidException.class,
() -> DruidSqlParserUtils.parseTimeStampWithTimeZone(
SqlLiteral.createUnknown(
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java
index 0e843b4ca2e..a43b0ee85f7 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java
@@ -23,11 +23,11 @@ import org.apache.calcite.avatica.util.Casing;
import org.apache.calcite.sql.SqlWriter;
import org.apache.calcite.sql.dialect.CalciteSqlDialect;
import org.apache.calcite.sql.pretty.SqlPrettyWriter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.io.StringReader;
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* A class containing unit tests for testing implementations of {@link org.apache.calcite.sql.SqlNode#unparse(SqlWriter, int, int)}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
index c283a364d1a..ee5a5b718f2 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java
@@ -54,13 +54,14 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
import org.easymock.EasyMock;
import org.easymock.EasyMockExtension;
import org.easymock.Mock;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import javax.validation.Validation;
import javax.validation.Validator;
+
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
@@ -154,29 +155,29 @@ public class CalcitePlannerModuleTest extends CalciteTestBase
public void testDruidOperatorTableIsInjectable()
{
DruidOperatorTable operatorTable = injector.getInstance(DruidOperatorTable.class);
- Assert.assertNotNull(operatorTable);
+ Assertions.assertNotNull(operatorTable);
// Should be a singleton.
DruidOperatorTable other = injector.getInstance(DruidOperatorTable.class);
- Assert.assertSame(other, operatorTable);
+ Assertions.assertSame(other, operatorTable);
}
@Test
public void testPlannerFactoryIsInjectable()
{
PlannerFactory plannerFactory = injector.getInstance(PlannerFactory.class);
- Assert.assertNotNull(PlannerFactory.class);
+ Assertions.assertNotNull(PlannerFactory.class);
// Should be a singleton.
PlannerFactory other = injector.getInstance(PlannerFactory.class);
- Assert.assertSame(other, plannerFactory);
+ Assertions.assertSame(other, plannerFactory);
}
@Test
public void testPlannerConfigIsInjected()
{
PlannerConfig plannerConfig = injector.getInstance(PlannerConfig.class);
- Assert.assertNotNull(plannerConfig);
+ Assertions.assertNotNull(plannerConfig);
}
@Test
@@ -199,7 +200,7 @@ public class CalcitePlannerModuleTest extends CalciteTestBase
boolean containsCustomRule = injector.getInstance(CalciteRulesManager.class)
.druidConventionRuleSet(context)
.contains(customRule);
- Assert.assertTrue(containsCustomRule);
+ Assertions.assertTrue(containsCustomRule);
}
@Test
@@ -239,6 +240,6 @@ public class CalcitePlannerModuleTest extends CalciteTestBase
.filter(rule -> rule instanceof ProjectMergeRule)
.map(rule -> (ProjectMergeRule) rule)
.findAny();
- Assert.assertTrue(firstProjectMergeRule.isPresent() && firstProjectMergeRule.get().config.bloat() == expectedBloat);
+ Assertions.assertTrue(firstProjectMergeRule.isPresent() && firstProjectMergeRule.get().config.bloat() == expectedBloat);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java
index a534b81aa06..1bb9e42dbf2 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java
@@ -20,7 +20,7 @@
package org.apache.druid.sql.calcite.planner;
import nl.jqno.equalsverifier.EqualsVerifier;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class ColumnMappingTest
{
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java
index 9ff62b4f16b..4ac524ab82b 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java
@@ -20,7 +20,7 @@
package org.apache.druid.sql.calcite.planner;
import nl.jqno.equalsverifier.EqualsVerifier;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class ColumnMappingsTest
{
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java
index bada2ace92c..cfdc598276c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java
@@ -20,19 +20,19 @@
package org.apache.druid.sql.calcite.planner;
import org.apache.druid.query.JoinAlgorithm;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
public class DruidHintTest
{
@Test
public void testFromString()
{
- Assert.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").id(), DruidHint.DruidJoinHint.SortMergeJoinHint.SORT_MERGE_JOIN);
- Assert.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").id(), DruidHint.DruidJoinHint.BroadcastJoinHint.BROADCAST_JOIN);
- Assert.assertNull(DruidHint.DruidJoinHint.fromString("hash"));
+ Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").id(), DruidHint.DruidJoinHint.SortMergeJoinHint.SORT_MERGE_JOIN);
+ Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").id(), DruidHint.DruidJoinHint.BroadcastJoinHint.BROADCAST_JOIN);
+ Assertions.assertNull(DruidHint.DruidJoinHint.fromString("hash"));
- Assert.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").asJoinAlgorithm(), JoinAlgorithm.SORT_MERGE);
- Assert.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").asJoinAlgorithm(), JoinAlgorithm.BROADCAST);
+ Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").asJoinAlgorithm(), JoinAlgorithm.SORT_MERGE);
+ Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").asJoinAlgorithm(), JoinAlgorithm.BROADCAST);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java
index f2a66e46e8f..a2490f71878 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java
@@ -31,15 +31,15 @@ import org.apache.druid.sql.calcite.expression.OperatorConversions;
import org.apache.druid.sql.calcite.expression.SqlOperatorConversion;
import org.apache.druid.sql.calcite.rel.Windowing;
import org.apache.druid.sql.calcite.table.RowSignatures;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
-import static org.junit.Assert.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertFalse;
public class DruidOperatorTableTest
{
@@ -48,22 +48,22 @@ public class DruidOperatorTableTest
{
DruidOperatorTable operatorTable = new DruidOperatorTable(ImmutableSet.of(), ImmutableSet.of());
List<SqlOperator> operatorList = operatorTable.getOperatorList();
- Assert.assertNotNull(operatorList);
- Assert.assertTrue("Built-in operators should be loaded by default", operatorList.size() > 0);
+ Assertions.assertNotNull(operatorList);
+ Assertions.assertTrue(operatorList.size() > 0, "Built-in operators should be loaded by default");
}
@Test
public void testIsFunctionSyntax()
{
- Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION));
- Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_STAR));
- Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_ID));
- Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.SPECIAL));
- Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.INTERNAL));
+ Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION));
+ Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_STAR));
+ Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_ID));
+ Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.SPECIAL));
+ Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.INTERNAL));
- Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.BINARY));
- Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.PREFIX));
- Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.POSTFIX));
+ Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.BINARY));
+ Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.PREFIX));
+ Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.POSTFIX));
}
@Test
@@ -91,15 +91,15 @@ public class DruidOperatorTableTest
DruidOperatorTable operatorTable = new DruidOperatorTable(ImmutableSet.of(), extractionOperators);
List<SqlOperator> operatorList = operatorTable.getOperatorList();
- Assert.assertNotNull(operatorList);
- Assert.assertTrue("We should have at least two operators -- the ones we loaded above plus the built-in"
- + " operators that gets loaded by default", operatorList.size() > 2);
+ Assertions.assertNotNull(operatorList);
+ Assertions.assertTrue(operatorList.size() > 2, "We should have at least two operators -- the ones we loaded above plus the built-in"
+ + " operators that gets loaded by default");
- Assert.assertTrue(operatorList.contains(operator1));
- Assert.assertTrue(operatorList.contains(operator2));
+ Assertions.assertTrue(operatorList.contains(operator1));
+ Assertions.assertTrue(operatorList.contains(operator2));
- Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(operator1.getSyntax()));
- Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(operator2.getSyntax()));
+ Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(operator1.getSyntax()));
+ Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(operator2.getSyntax()));
}
@Test
@@ -118,8 +118,8 @@ public class DruidOperatorTableTest
continue;
default:
assertFalse(
- operator + " allows framing; should be supported or rejected and then exclude from this check",
- operator.allowsFraming()
+ operator.allowsFraming(),
+ operator + " allows framing; should be supported or rejected and then exclude from this check"
);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
index f58340d2b89..2f387bdc125 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java
@@ -61,8 +61,8 @@ import org.apache.druid.sql.hook.DruidHookDispatcher;
import org.apache.druid.testing.InitializedNullHandlingTest;
import org.easymock.EasyMock;
import org.joda.time.DateTimeZone;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
import java.util.ArrayList;
@@ -141,9 +141,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
List<RexNode> reduced = new ArrayList<>();
rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
- Assert.assertEquals(new BigDecimal(30L), ((RexLiteral) reduced.get(0)).getValue());
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+ Assertions.assertEquals(new BigDecimal(30L), ((RexLiteral) reduced.get(0)).getValue());
}
@Test
@@ -159,9 +159,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
List<RexNode> reduced = new ArrayList<>();
rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
- Assert.assertEquals(
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+ Assertions.assertEquals(
rexBuilder.makeDateLiteral(
Calcites.jodaToCalciteDateString(
DateTimes.of("2010-01-01"),
@@ -184,9 +184,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
List<RexNode> reduced = new ArrayList<>();
rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
- Assert.assertEquals(
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+ Assertions.assertEquals(
Calcites.jodaToCalciteTimestampLiteral(
rexBuilder,
DateTimes.of("2010-01-01T02:03:04Z"),
@@ -209,9 +209,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT);
List<RexNode> reduced = new ArrayList<>();
rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
- Assert.assertTrue(RexLiteral.isNullLiteral(reduced.get(0)));
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind());
+ Assertions.assertTrue(RexLiteral.isNullLiteral(reduced.get(0)));
}
@Test
@@ -221,9 +221,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
RexNode call = rexBuilder.makeCall(OPERATOR);
List<RexNode> reduced = new ArrayList<>();
rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
- Assert.assertEquals(
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
+ Assertions.assertEquals(
CalciteTestBase.makeExpression(ColumnType.ofComplex("hyperUnique"), "hyper_unique()"),
Expressions.toDruidExpression(
PLANNER_CONTEXT,
@@ -243,8 +243,8 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
List<BigDecimal> elements = ImmutableList.of(BigDecimal.valueOf(50.12), BigDecimal.valueOf(12.1));
RexNode literal = rexBuilder.makeLiteral(elements, arraySqlType, true);
rexy.reduce(rexBuilder, ImmutableList.of(literal), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(
DruidExpression.ofExpression(
ColumnType.DOUBLE_ARRAY,
DruidExpression.functionCall("array"),
@@ -271,8 +271,8 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
List<BigDecimal> elements = ImmutableList.of(BigDecimal.valueOf(50), BigDecimal.valueOf(12));
RexNode literal = rexBuilder.makeLiteral(elements, arraySqlType, true);
rexy.reduce(rexBuilder, ImmutableList.of(literal), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(
DruidExpression.ofExpression(
ColumnType.LONG_ARRAY,
DruidExpression.functionCall("array"),
@@ -300,9 +300,9 @@ public class DruidRexExecutorTest extends InitializedNullHandlingTest
);
List<RexNode> reduced = new ArrayList<>();
rexy.reduce(rexBuilder, ImmutableList.of(call), reduced);
- Assert.assertEquals(1, reduced.size());
- Assert.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
- Assert.assertEquals(
+ Assertions.assertEquals(1, reduced.size());
+ Assertions.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind());
+ Assertions.assertEquals(
DruidExpression.ofExpression(
ColumnType.STRING,
DruidExpression.functionCall("string_to_array"),
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java
index c54e46a14dd..f209fc437ae 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.sql.calcite.planner;
import com.google.common.collect.ImmutableList;
import org.apache.druid.java.util.common.StringUtils;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.stream.Collectors;
@@ -42,14 +42,7 @@ public class OffsetLimitTest
final OffsetLimit outer = new OffsetLimit(outerOffset, outerLimit < 0 ? null : (long) outerLimit);
final OffsetLimit combined = inner.andThen(outer);
- Assert.assertEquals(
- StringUtils.format(
- "innerOffset[%s], innerLimit[%s], outerOffset[%s], outerLimit[%s]",
- innerOffset,
- innerLimit,
- outerOffset,
- outerLimit
- ),
+ Assertions.assertEquals(
things.stream()
.skip(innerOffset)
.limit(innerLimit < 0 ? Long.MAX_VALUE : innerLimit)
@@ -59,7 +52,14 @@ public class OffsetLimitTest
things.stream()
.skip(combined.getOffset())
.limit(combined.hasLimit() ? combined.getLimit() : Long.MAX_VALUE)
- .collect(Collectors.toList())
+ .collect(Collectors.toList()),
+ StringUtils.format(
+ "innerOffset[%s], innerLimit[%s], outerOffset[%s], outerLimit[%s]",
+ innerOffset,
+ innerLimit,
+ outerOffset,
+ outerLimit
+ )
);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java
index c622f279325..6b3442132aa 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.sql.calcite.planner;
import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
public class PlannerConfigTest
{
@@ -30,9 +30,9 @@ public class PlannerConfigTest
public void testPlannerConfigDefaults()
{
PlannerConfig config = new PlannerConfig();
- Assert.assertFalse(config.isUseLexicographicTopN());
- Assert.assertTrue(config.isUseApproximateTopN());
- Assert.assertTrue(config.isUseApproximateCountDistinct());
+ Assertions.assertFalse(config.isUseLexicographicTopN());
+ Assertions.assertTrue(config.isUseApproximateTopN());
+ Assertions.assertTrue(config.isUseApproximateCountDistinct());
}
@Test
@@ -41,8 +41,8 @@ public class PlannerConfigTest
PlannerConfig config = PlannerConfig.builder()
.useLexicographicTopN(true)
.build();
- Assert.assertTrue(config.isUseLexicographicTopN());
- Assert.assertTrue(config.isUseApproximateTopN());
+ Assertions.assertTrue(config.isUseLexicographicTopN());
+ Assertions.assertTrue(config.isUseApproximateTopN());
}
@Test
@@ -52,8 +52,8 @@ public class PlannerConfigTest
.useLexicographicTopN(false)
.useApproximateTopN(false)
.build();
- Assert.assertFalse(config.isUseLexicographicTopN());
- Assert.assertFalse(config.isUseApproximateTopN());
+ Assertions.assertFalse(config.isUseLexicographicTopN());
+ Assertions.assertFalse(config.isUseApproximateTopN());
}
@Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java
index 613aebfcdfd..d821905315c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java
@@ -27,8 +27,8 @@ import org.apache.druid.sql.calcite.table.DruidTable;
import java.util.Collections;
import java.util.Set;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Test class to reference items that are otherwise unused in this package, and
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java
index 70d76d4c753..95c95757180 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java
@@ -38,8 +38,8 @@ import org.apache.druid.sql.calcite.filtration.Filtration;
import org.apache.druid.sql.calcite.planner.ExpressionParserImpl;
import org.apache.druid.sql.calcite.util.CalciteTests;
import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.Collections;
@@ -221,8 +221,8 @@ public class DruidQueryTest
Interval interval
)
{
- Assert.assertEquals(dataSource, pair.lhs);
- Assert.assertEquals("dim-filter: " + pair.rhs.getDimFilter(), columnFilter, pair.rhs.getDimFilter());
- Assert.assertEquals(Collections.singletonList(interval), pair.rhs.getIntervals());
+ Assertions.assertEquals(dataSource, pair.lhs);
+ Assertions.assertEquals(columnFilter, pair.rhs.getDimFilter(), "dim-filter: " + pair.rhs.getDimFilter());
+ Assertions.assertEquals(Collections.singletonList(interval), pair.rhs.getIntervals());
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
index 61dcd59ea1d..f342d844acc 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java
@@ -68,9 +68,9 @@ import org.apache.druid.sql.calcite.rel.logical.DruidUnion;
import org.apache.druid.sql.calcite.table.DatasourceTable;
import org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata;
import org.apache.druid.sql.calcite.table.DruidTable;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
@@ -118,7 +118,7 @@ public class DruidRelTest
private PlannerContext mockPlannerContext;
private DruidQueryRel druidQueryRelNode;
- @Before
+ @BeforeEach
public void setup() throws Exception
{
MockitoAnnotations.openMocks(this);
@@ -154,9 +154,9 @@ public class DruidRelTest
DruidQuery query = druidQueryRelNode.toDruidQuery(true);
// explain query should return a TableDataSource.
- Assert.assertEquals(TABLE, queryForExplaining.getDataSource());
+ Assertions.assertEquals(TABLE, queryForExplaining.getDataSource());
// query should return a RestrictedDataSource.
- Assert.assertEquals(RESTRICTED, query.getDataSource());
+ Assertions.assertEquals(RESTRICTED, query.getDataSource());
}
@Test
@@ -180,10 +180,10 @@ public class DruidRelTest
DruidQuery query = joinRel.toDruidQuery(false);
// Assert
- Assert.assertEquals(DruidJoinQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+ Assertions.assertEquals(DruidJoinQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
JoinDataSource dataSource = (JoinDataSource) query.getDataSource();
- Assert.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getLeft()).getQuery().getDataSource());
- Assert.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getRight()).getQuery().getDataSource());
+ Assertions.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getLeft()).getQuery().getDataSource());
+ Assertions.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getRight()).getQuery().getDataSource());
}
@Test
@@ -204,8 +204,8 @@ public class DruidRelTest
DruidQuery query = rel.toDruidQuery(false);
// Assert
- Assert.assertEquals(DruidUnionDataSourceRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
- Assert.assertEquals(new UnionDataSource(ImmutableList.of(RESTRICTED, RESTRICTED)), query.getDataSource());
+ Assertions.assertEquals(DruidUnionDataSourceRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+ Assertions.assertEquals(new UnionDataSource(ImmutableList.of(RESTRICTED, RESTRICTED)), query.getDataSource());
}
@Test
@@ -225,8 +225,8 @@ public class DruidRelTest
DruidQuery query = rel.toDruidQuery(false);
// Assert
- Assert.assertEquals(DruidOuterQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
- Assert.assertEquals(RESTRICTED, ((QueryDataSource) query.getDataSource()).getQuery().getDataSource());
+ Assertions.assertEquals(DruidOuterQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+ Assertions.assertEquals(RESTRICTED, ((QueryDataSource) query.getDataSource()).getQuery().getDataSource());
}
@Test
@@ -253,8 +253,8 @@ public class DruidRelTest
DruidQuery query = rel.toDruidQuery(false);
// Assert
- Assert.assertEquals(DruidCorrelateUnnestRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
- Assert.assertEquals(RESTRICTED, ((UnnestDataSource) query.getDataSource()).getBase());
+ Assertions.assertEquals(DruidCorrelateUnnestRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource());
+ Assertions.assertEquals(RESTRICTED, ((UnnestDataSource) query.getDataSource()).getBase());
}
@Test
@@ -262,10 +262,10 @@ public class DruidRelTest
{
DruidUnnestRel rel = DruidUnnestRel.create(mockRelOptCluster, mockRelTraitSet, ALWAYS_TRUE, mockPlannerContext);
- CannotBuildQueryException e1 = Assert.assertThrows(CannotBuildQueryException.class, rel::toDruidQueryForExplaining);
- CannotBuildQueryException e2 = Assert.assertThrows(CannotBuildQueryException.class, () -> rel.toDruidQuery(false));
- Assert.assertEquals("Cannot execute UNNEST directly", e1.getMessage());
- Assert.assertEquals("Cannot execute UNNEST directly", e2.getMessage());
+ CannotBuildQueryException e1 = Assertions.assertThrows(CannotBuildQueryException.class, rel::toDruidQueryForExplaining);
+ CannotBuildQueryException e2 = Assertions.assertThrows(CannotBuildQueryException.class, () -> rel.toDruidQuery(false));
+ Assertions.assertEquals("Cannot execute UNNEST directly", e1.getMessage());
+ Assertions.assertEquals("Cannot execute UNNEST directly", e2.getMessage());
}
@Test
@@ -273,11 +273,11 @@ public class DruidRelTest
{
DruidUnionRel rel = DruidUnionRel.create(mockPlannerContext, REC_TYPE, ImmutableList.of(druidQueryRelNode), 1000);
- UnsupportedOperationException e1 = Assert.assertThrows(
+ UnsupportedOperationException e1 = Assertions.assertThrows(
UnsupportedOperationException.class,
rel::toDruidQueryForExplaining
);
- UnsupportedOperationException e2 = Assert.assertThrows(
+ UnsupportedOperationException e2 = Assertions.assertThrows(
UnsupportedOperationException.class,
() -> rel.toDruidQuery(false)
);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java
index e5daa3471e1..bf0561cda4d 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java
@@ -28,10 +28,11 @@ import org.apache.calcite.util.mapping.MappingType;
import org.apache.calcite.util.mapping.Mappings;
import org.apache.druid.sql.calcite.table.DruidTable;
import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import javax.annotation.Nullable;
+
import java.util.List;
import java.util.function.Consumer;
@@ -41,8 +42,8 @@ public class DruidRelsTest
public void test_isScanOrMapping_scan()
{
final DruidRel<?> rel = mockDruidRel(DruidQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery());
}
@@ -50,8 +51,8 @@ public class DruidRelsTest
public void test_isScanOrMapping_scanJoin()
{
final DruidRel<?> rel = mockDruidRel(DruidJoinQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery());
}
@@ -59,8 +60,8 @@ public class DruidRelsTest
public void test_isScanOrMapping_scanUnion()
{
final DruidRel<?> rel = mockDruidRel(DruidUnionDataSourceRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery());
}
@@ -68,8 +69,8 @@ public class DruidRelsTest
public void test_isScanOrMapping_scanQuery()
{
final DruidRel<?> rel = mockDruidRel(DruidOuterQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery());
}
@@ -84,8 +85,8 @@ public class DruidRelsTest
project,
null
);
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -101,8 +102,8 @@ public class DruidRelsTest
project,
null
);
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -118,8 +119,8 @@ public class DruidRelsTest
project,
null
);
- Assert.assertTrue(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -135,8 +136,8 @@ public class DruidRelsTest
project,
null
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -152,8 +153,8 @@ public class DruidRelsTest
project,
null
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -169,8 +170,8 @@ public class DruidRelsTest
project,
null
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -186,8 +187,8 @@ public class DruidRelsTest
project,
null
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -203,8 +204,8 @@ public class DruidRelsTest
project,
mockFilter()
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -220,8 +221,8 @@ public class DruidRelsTest
project,
mockFilter()
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -237,8 +238,8 @@ public class DruidRelsTest
project,
mockFilter()
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
@@ -253,8 +254,8 @@ public class DruidRelsTest
null,
mockFilter()
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery());
}
@@ -269,8 +270,8 @@ public class DruidRelsTest
null,
mockFilter()
);
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, true));
- Assert.assertFalse(DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true));
+ Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false));
EasyMock.verify(rel, rel.getPartialDruidQuery());
}
@@ -293,8 +294,8 @@ public class DruidRelsTest
null
);
- Assert.assertEquals(stage.toString(), okStages.contains(stage), DruidRels.isScanOrMapping(rel, true));
- Assert.assertEquals(stage.toString(), okStages.contains(stage), DruidRels.isScanOrMapping(rel, false));
+ Assertions.assertEquals(okStages.contains(stage), DruidRels.isScanOrMapping(rel, true), stage.toString());
+ Assertions.assertEquals(okStages.contains(stage), DruidRels.isScanOrMapping(rel, false), stage.toString());
EasyMock.verify(rel, rel.getPartialDruidQuery(), project);
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java
index eb4d64b4537..1fed2871140 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java
@@ -24,7 +24,7 @@ import nl.jqno.equalsverifier.EqualsVerifier;
import org.apache.druid.java.util.common.StringUtils;
import org.apache.druid.segment.column.ColumnType;
import org.apache.druid.sql.calcite.expression.DruidExpression;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class GroupingTest
{
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java
index c4312b0ae25..1546e5b98d1 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java
@@ -34,9 +34,9 @@ import org.apache.druid.query.JoinAlgorithm;
import org.apache.druid.query.QueryContext;
import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
import org.apache.druid.sql.calcite.planner.PlannerContext;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.math.BigDecimal;
@@ -66,7 +66,7 @@ public class DruidJoinRuleTest
private DruidJoinRule druidJoinRule;
- @Before
+ @BeforeEach
public void setup()
{
PlannerContext plannerContext = Mockito.mock(PlannerContext.class);
@@ -78,7 +78,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_leftEqRight()
{
- Assert.assertTrue(
+ Assertions.assertTrue(
druidJoinRule.canHandleCondition(
rexBuilder.makeCall(
SqlStdOperatorTable.EQUALS,
@@ -97,7 +97,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_leftFnEqRight()
{
- Assert.assertTrue(
+ Assertions.assertTrue(
druidJoinRule.canHandleCondition(
rexBuilder.makeCall(
SqlStdOperatorTable.EQUALS,
@@ -120,7 +120,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_leftEqRightFn()
{
- Assert.assertTrue(
+ Assertions.assertTrue(
druidJoinRule.canHandleCondition(
rexBuilder.makeCall(
SqlStdOperatorTable.EQUALS,
@@ -144,7 +144,7 @@ public class DruidJoinRuleTest
public void test_canHandleCondition_leftEqLeft()
{
- Assert.assertTrue(
+ Assertions.assertTrue(
druidJoinRule.canHandleCondition(
rexBuilder.makeCall(
SqlStdOperatorTable.EQUALS,
@@ -163,7 +163,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_rightEqRight()
{
- Assert.assertTrue(
+ Assertions.assertTrue(
druidJoinRule.canHandleCondition(
rexBuilder.makeCall(
SqlStdOperatorTable.EQUALS,
@@ -182,7 +182,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_leftEqRightFn_leftJoin()
{
- Assert.assertFalse(
+ Assertions.assertFalse(
druidJoinRule.canHandleCondition(
rexBuilder.makeCall(
SqlStdOperatorTable.EQUALS,
@@ -205,7 +205,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_leftEqRightFn_systemFields()
{
- Assert.assertFalse(
+ Assertions.assertFalse(
druidJoinRule.canHandleCondition(
rexBuilder.makeCall(
SqlStdOperatorTable.EQUALS,
@@ -228,7 +228,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_true()
{
- Assert.assertTrue(
+ Assertions.assertTrue(
druidJoinRule.canHandleCondition(
rexBuilder.makeLiteral(true),
leftType,
@@ -243,7 +243,7 @@ public class DruidJoinRuleTest
@Test
public void test_canHandleCondition_false()
{
- Assert.assertTrue(
+ Assertions.assertTrue(
druidJoinRule.canHandleCondition(
rexBuilder.makeLiteral(false),
leftType,
@@ -260,8 +260,8 @@ public class DruidJoinRuleTest
{
final List<RexNode> rexNodes = DruidJoinRule.decomposeAnd(rexBuilder.makeInputRef(leftType, 0));
- Assert.assertEquals(1, rexNodes.size());
- Assert.assertEquals(rexBuilder.makeInputRef(leftType, 0), Iterables.getOnlyElement(rexNodes));
+ Assertions.assertEquals(1, rexNodes.size());
+ Assertions.assertEquals(rexBuilder.makeInputRef(leftType, 0), Iterables.getOnlyElement(rexNodes));
}
@Test
@@ -283,7 +283,7 @@ public class DruidJoinRuleTest
)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
rexBuilder.makeExactLiteral(BigDecimal.valueOf(1)),
rexBuilder.makeExactLiteral(BigDecimal.valueOf(2)),
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java
index 54619b5b10b..63d3cbaf63e 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java
@@ -36,14 +36,13 @@ import org.apache.druid.sql.calcite.planner.PlannerContext;
import org.apache.druid.testing.InitializedNullHandlingTest;
import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mockito;
import java.math.BigDecimal;
@@ -52,10 +51,11 @@ public class DruidLogicalValuesRuleTest
{
private static final PlannerContext DEFAULT_CONTEXT = Mockito.mock(PlannerContext.class);
- @RunWith(Parameterized.class)
- public static class GetValueFromLiteralSimpleTypesTest extends InitializedNullHandlingTest
+ @Nested
+ @ParameterizedClass(name = "{1}, {2}")
+ @MethodSource("constructorFeeder")
+ public class GetValueFromLiteralSimpleTypesTest extends InitializedNullHandlingTest
{
- @Parameters(name = "{1}, {2}")
public static Iterable<Object[]> constructorFeeder()
{
return ImmutableList.of(
@@ -87,8 +87,8 @@ public class DruidLogicalValuesRuleTest
{
final RexLiteral literal = Mockito.spy(makeLiteral(val, sqlTypeName, javaType));
final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
- Assert.assertSame(javaType, fromLiteral.getClass());
- Assert.assertEquals(val, fromLiteral);
+ Assertions.assertSame(javaType, fromLiteral.getClass());
+ Assertions.assertEquals(val, fromLiteral);
Mockito.verify(literal, Mockito.times(1)).getType();
}
@@ -106,18 +106,17 @@ public class DruidLogicalValuesRuleTest
}
}
- public static class GetValueFromLiteralOtherTypesTest
+ @Nested
+ @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+ public class GetValueFromLiteralOtherTypesTest
{
private static final PlannerContext DEFAULT_CONTEXT = Mockito.mock(PlannerContext.class);
private static final DateTimeZone TIME_ZONE = DateTimes.inferTzFromString("Asia/Seoul");
private static final RelDataTypeFactory TYPE_FACTORY = new SqlTypeFactoryImpl(DruidTypeSystem.INSTANCE);
private static final RexBuilder REX_BUILDER = new RexBuilder(TYPE_FACTORY);
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
-
- @BeforeClass
- public static void setup()
+ @BeforeAll
+ public void setup()
{
Mockito.when(DEFAULT_CONTEXT.getTimeZone()).thenReturn(TIME_ZONE);
}
@@ -128,8 +127,8 @@ public class DruidLogicalValuesRuleTest
RexLiteral literal = REX_BUILDER.makeLiteral(true);
final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
- Assert.assertSame(Long.class, fromLiteral.getClass());
- Assert.assertEquals(1L, fromLiteral);
+ Assertions.assertSame(Long.class, fromLiteral.getClass());
+ Assertions.assertEquals(1L, fromLiteral);
}
@Test
@@ -138,8 +137,8 @@ public class DruidLogicalValuesRuleTest
RexLiteral literal = REX_BUILDER.makeLiteral(false);
final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
- Assert.assertSame(Long.class, fromLiteral.getClass());
- Assert.assertEquals(0L, fromLiteral);
+ Assertions.assertSame(Long.class, fromLiteral.getClass());
+ Assertions.assertEquals(0L, fromLiteral);
}
@Test
@@ -148,7 +147,7 @@ public class DruidLogicalValuesRuleTest
RexLiteral literal = REX_BUILDER.makeLiteral(null, REX_BUILDER.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN));
final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
- Assert.assertNull(fromLiteral);
+ Assertions.assertNull(fromLiteral);
}
@Test
@@ -157,8 +156,8 @@ public class DruidLogicalValuesRuleTest
RexLiteral literal = REX_BUILDER.makeTimestampLiteral(new TimestampString("2021-04-01 16:54:31"), 0);
final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
- Assert.assertSame(Long.class, fromLiteral.getClass());
- Assert.assertEquals(new DateTime("2021-04-01T16:54:31", TIME_ZONE).getMillis(), fromLiteral);
+ Assertions.assertSame(Long.class, fromLiteral.getClass());
+ Assertions.assertEquals(new DateTime("2021-04-01T16:54:31", TIME_ZONE).getMillis(), fromLiteral);
}
@Test
@@ -167,8 +166,8 @@ public class DruidLogicalValuesRuleTest
RexLiteral literal = REX_BUILDER.makeDateLiteral(new DateString("2021-04-01"));
final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
- Assert.assertSame(Long.class, fromLiteral.getClass());
- Assert.assertEquals(new DateTime("2021-04-01", TIME_ZONE).getMillis(), fromLiteral);
+ Assertions.assertSame(Long.class, fromLiteral.getClass());
+ Assertions.assertEquals(new DateTime("2021-04-01", TIME_ZONE).getMillis(), fromLiteral);
}
@Test
@@ -178,42 +177,36 @@ public class DruidLogicalValuesRuleTest
new TimestampString("2021-04-01 16:54:31"),
0
);
- expectedException.expect(
- DruidExceptionMatcher
- .invalidSqlInput()
- .expectMessageIs(
- "Cannot handle literal [2021-04-01 16:54:31:TIMESTAMP_WITH_LOCAL_TIME_ZONE(0)] "
- + "of unsupported type [TIMESTAMP_WITH_LOCAL_TIME_ZONE]."
- )
- );
- DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
+ DruidExceptionMatcher
+ .invalidSqlInput()
+ .expectMessageIs(
+ "Cannot handle literal [2021-04-01 16:54:31:TIMESTAMP_WITH_LOCAL_TIME_ZONE(0)] "
+ + "of unsupported type [TIMESTAMP_WITH_LOCAL_TIME_ZONE]."
+ )
+ .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT));
}
@Test
public void testGetValueFromTimeLiteral()
{
RexLiteral literal = REX_BUILDER.makeTimeLiteral(new TimeString("16:54:31"), 0);
- expectedException.expect(
- DruidExceptionMatcher
- .invalidSqlInput()
- .expectMessageIs("Cannot handle literal [16:54:31] of unsupported type [TIME].")
- );
- DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
+ DruidExceptionMatcher
+ .invalidSqlInput()
+ .expectMessageIs("Cannot handle literal [16:54:31] of unsupported type [TIME].")
+ .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT));
}
@Test
public void testGetValueFromTimeWithLocalTimeZoneLiteral()
{
RexLiteral literal = REX_BUILDER.makeTimeWithLocalTimeZoneLiteral(new TimeString("16:54:31"), 0);
- expectedException.expect(
- DruidExceptionMatcher
- .invalidSqlInput()
- .expectMessageIs(
- "Cannot handle literal [16:54:31:TIME_WITH_LOCAL_TIME_ZONE(0)] "
- + "of unsupported type [TIME_WITH_LOCAL_TIME_ZONE]."
- )
- );
- DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
+ DruidExceptionMatcher
+ .invalidSqlInput()
+ .expectMessageIs(
+ "Cannot handle literal [16:54:31:TIME_WITH_LOCAL_TIME_ZONE(0)] "
+ + "of unsupported type [TIME_WITH_LOCAL_TIME_ZONE]."
+ )
+ .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT));
}
@Test
@@ -224,7 +217,7 @@ public class DruidLogicalValuesRuleTest
TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)
);
Object value = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT);
- Assert.assertEquals(value, 123L);
+ Assertions.assertEquals(value, 123L);
}
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java
index 9d6bad13bd5..4cb21c16011 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java
@@ -36,8 +36,8 @@ import org.apache.druid.sql.calcite.table.DatasourceTable;
import org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata;
import org.apache.druid.sql.calcite.table.DruidTable;
import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.List;
@@ -69,7 +69,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.of(ImmutableList.of("__time", "col1", "col2")),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -86,7 +86,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.of(ImmutableList.of("col1")),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -103,7 +103,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.empty(),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -120,7 +120,7 @@ public class DruidUnionDataSourceRuleTest
DruidRelsTest.mockFilter()
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.empty(),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -138,7 +138,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.of(ImmutableList.of("__time", "col1", "col2")),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -165,7 +165,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.of(ImmutableList.of("col2", "col1")),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -183,7 +183,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.of(ImmutableList.of("__time", "col1", "col2")),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -200,7 +200,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.empty(),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
@@ -217,7 +217,7 @@ public class DruidUnionDataSourceRuleTest
null
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Optional.empty(),
DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null)
);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java
index bbce9836607..acd83de6ede 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java
@@ -30,8 +30,8 @@ import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.druid.sql.calcite.expression.builtin.ConcatOperatorConversion;
import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.math.BigDecimal;
import java.util.Arrays;
@@ -51,7 +51,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
literal("2")
);
- Assert.assertEquals(call, shuttle.apply(call));
+ Assertions.assertEquals(call, shuttle.apply(call));
}
@Test
@@ -60,7 +60,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode concatCall =
concat(literal("it's "), inputRef(0));
- Assert.assertEquals(
+ Assertions.assertEquals(
and(equals(inputRef(0), literal("2"))),
shuttle.apply(equals(concatCall, literal("it's 2")))
);
@@ -72,7 +72,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode concatCall =
concat(literal("it's "), inputRef(0));
- Assert.assertEquals(
+ Assertions.assertEquals(
and(equals(inputRef(0), literal("2"))),
shuttle.apply(equals(literal("it's 2"), concatCall))
);
@@ -83,7 +83,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
{
final RexNode concatCall = concat(inputRef(0));
- Assert.assertEquals(
+ Assertions.assertEquals(
and(equals(inputRef(0), literal("it's 2"))),
shuttle.apply(equals(literal("it's 2"), concatCall))
);
@@ -95,7 +95,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode concatCall =
concat(inputRef(0), literal("x"), inputRef(1));
- Assert.assertEquals(
+ Assertions.assertEquals(
and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3"))),
shuttle.apply(equals(concatCall, literal("2x3")))
);
@@ -116,7 +116,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode concatCall =
concat(numericInputRef, literal("x"), inputRef(1));
- Assert.assertEquals(
+ Assertions.assertEquals(
and(
equals(
numericInputRef,
@@ -140,7 +140,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
literal("2x3")
);
- Assert.assertEquals(
+ Assertions.assertEquals(
rexBuilder.makeCall(
SqlStdOperatorTable.NOT,
and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3")))
@@ -160,7 +160,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode concatCall =
concat(inputRef(0), three, inputRef(1), literal("4"));
- Assert.assertEquals(
+ Assertions.assertEquals(
and(equals(inputRef(0), literal("x")), equals(inputRef(1), literal("y"))),
shuttle.apply(equals(concatCall, literal("x3y4")))
);
@@ -170,7 +170,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
public void test_twoInputs_noLiteral()
{
final RexNode call = equals(concat(inputRef(0), inputRef(1)), literal("2x3"));
- Assert.assertEquals(call, shuttle.apply(call));
+ Assertions.assertEquals(call, shuttle.apply(call));
}
@Test
@@ -179,7 +179,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode call =
isNull(concat(inputRef(0), literal("x"), inputRef(1)));
- Assert.assertEquals(
+ Assertions.assertEquals(
or(isNull(inputRef(0)), isNull(inputRef(1))),
shuttle.apply(call)
);
@@ -191,7 +191,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode call =
notNull(concat(inputRef(0), literal("x"), inputRef(1)));
- Assert.assertEquals(
+ Assertions.assertEquals(
rexBuilder.makeCall(
SqlStdOperatorTable.NOT,
or(isNull(inputRef(0)), isNull(inputRef(1)))
@@ -209,7 +209,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
literal("2xx3") // ambiguous match
);
- Assert.assertEquals(call, shuttle.apply(call));
+ Assertions.assertEquals(call, shuttle.apply(call));
}
@Test
@@ -222,7 +222,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
);
final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
- Assert.assertEquals(
+ Assertions.assertEquals(
or(
and(isNull(inputRef(0)), unknown),
and(isNull(inputRef(1)), unknown)
@@ -241,7 +241,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
);
final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
- Assert.assertEquals(
+ Assertions.assertEquals(
or(
and(isNull(inputRef(0)), unknown),
and(isNull(inputRef(1)), unknown)
@@ -259,7 +259,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
literal("23") // must be recognized as ambiguous
);
- Assert.assertEquals(call, shuttle.apply(call));
+ Assertions.assertEquals(call, shuttle.apply(call));
}
@Test
@@ -271,7 +271,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
literal("2---3") // must be recognized as ambiguous
);
- Assert.assertEquals(call, shuttle.apply(call));
+ Assertions.assertEquals(call, shuttle.apply(call));
}
@Test
@@ -284,7 +284,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
);
final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
- Assert.assertEquals(
+ Assertions.assertEquals(
or(
and(isNull(inputRef(0)), unknown),
and(isNull(inputRef(1)), unknown)
@@ -302,7 +302,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
literal("xxx (4x5)") // unambiguous, because 'x' before ' (' can be ignored
);
- Assert.assertEquals(
+ Assertions.assertEquals(
and(
equals(inputRef(0), literal("xxx")),
equals(inputRef(1), literal("4")),
@@ -318,7 +318,7 @@ public class FilterDecomposeConcatRuleTest extends InitializedNullHandlingTest
final RexNode concatCall =
concat(inputRef(0), literal("x"), literal("y"), inputRef(1));
- Assert.assertEquals(
+ Assertions.assertEquals(
and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3"))),
shuttle.apply(equals(concatCall, literal("2xy3")))
);
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java
index 48843fc2760..9f9c503aa5b 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java
@@ -29,8 +29,8 @@ import org.apache.calcite.sql.fun.SqlStdOperatorTable;
import org.apache.calcite.sql.type.SqlTypeFactoryImpl;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.druid.sql.calcite.planner.DruidTypeSystem;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
@@ -57,16 +57,16 @@ public class FilterJoinExcludePushToChildRuleTest
joinFilters.add(equalityFilter);
FilterJoinExcludePushToChildRule.removeRedundantIsNotNullFilters(joinFilters, JoinRelType.INNER);
- Assert.assertEquals(joinFilters.size(), 1);
- Assert.assertEquals("Equality Filter changed", joinFilters.get(0), equalityFilter);
+ Assertions.assertEquals(joinFilters.size(), 1);
+ Assertions.assertEquals(joinFilters.get(0), equalityFilter, "Equality Filter changed");
// add IS NOT NULL filter on a join column
joinFilters.add(isNotNullFilterOnNonJoinColumn);
joinFilters.add(isNotNullFilterOnJoinColumn);
- Assert.assertEquals(joinFilters.size(), 3);
+ Assertions.assertEquals(joinFilters.size(), 3);
FilterJoinExcludePushToChildRule.removeRedundantIsNotNullFilters(joinFilters, JoinRelType.INNER);
- Assert.assertEquals(joinFilters.size(), 2);
- Assert.assertEquals("Equality Filter changed", joinFilters.get(0), equalityFilter);
- Assert.assertEquals("IS NOT NULL filter on non-join column changed", joinFilters.get(1), isNotNullFilterOnNonJoinColumn);
+ Assertions.assertEquals(joinFilters.size(), 2);
+ Assertions.assertEquals(joinFilters.get(0), equalityFilter, "Equality Filter changed");
+ Assertions.assertEquals(joinFilters.get(1), isNotNullFilterOnNonJoinColumn, "IS NOT NULL filter on non-join column changed");
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java
index 62190fb0c69..6547d7c881e 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java
@@ -21,7 +21,7 @@ package org.apache.druid.sql.calcite.run;
import nl.jqno.equalsverifier.EqualsVerifier;
import org.apache.druid.sql.hook.DruidHook;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
public class DruidHookTest
{
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java
index 027e9022124..64d3b1ca4c4 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java
@@ -28,13 +28,10 @@ import org.apache.druid.error.DruidException;
import org.apache.druid.java.util.common.StringUtils;
import org.apache.druid.segment.TestHelper;
import org.apache.druid.testing.InitializedNullHandlingTest;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.MatcherAssert;
import org.joda.time.DateTimeZone;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.internal.matchers.ThrowableMessageMatcher;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Collections;
@@ -46,7 +43,7 @@ public class SqlResultsTest extends InitializedNullHandlingTest
private ObjectMapper jsonMapper;
- @Before
+ @BeforeEach
public void setUp()
{
jsonMapper = TestHelper.JSON_MAPPER;
@@ -227,10 +224,10 @@ public class SqlResultsTest extends InitializedNullHandlingTest
{
try {
assertCoerce("", new byte[1], SqlTypeName.BIGINT);
- Assert.fail("Should throw an exception");
+ Assertions.fail("Should throw an exception");
}
catch (Exception e) {
- Assert.assertEquals("Cannot coerce field [fieldName] from type [Byte Array] to type [BIGINT]", e.getMessage());
+ Assertions.assertEquals("Cannot coerce field [fieldName] from type [Byte Array] to type [BIGINT]", e.getMessage());
}
}
@@ -243,7 +240,7 @@ public class SqlResultsTest extends InitializedNullHandlingTest
@Test
public void testMayNotCoerceList()
{
- Assert.assertEquals("hello", SqlResults.coerceArrayToList("hello", false));
+ Assertions.assertEquals("hello", SqlResults.coerceArrayToList("hello", false));
}
@Test
@@ -254,27 +251,27 @@ public class SqlResultsTest extends InitializedNullHandlingTest
private void assertCoerce(Object expected, Object toCoerce, SqlTypeName typeName)
{
- Assert.assertEquals(
- StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName),
+ Assertions.assertEquals(
expected,
- SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "fieldName")
+ SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "fieldName"),
+ StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName)
);
}
private void assertCannotCoerce(Object toCoerce, SqlTypeName typeName)
{
- final DruidException e = Assert.assertThrows(
- StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName),
+ final DruidException e = Assertions.assertThrows(
DruidException.class,
- () -> SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "")
+ () -> SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, ""),
+ StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName)
);
- MatcherAssert.assertThat(e, ThrowableMessageMatcher.hasMessage(CoreMatchers.containsString("Cannot coerce")));
+ Assertions.assertTrue(e.getMessage().contains("Cannot coerce"));
}
private void assertCoerceArrayToList(Object expected, Object toCoerce)
{
Object coerced = SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, SqlTypeName.ARRAY, "");
- Assert.assertEquals(expected, coerced);
+ Assertions.assertEquals(expected, coerced);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
index 487c50570f3..ce56ed4155a 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java
@@ -126,6 +126,7 @@ import org.apache.druid.timeline.DataSegment;
import org.apache.druid.utils.JvmUtils;
import javax.inject.Named;
+
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
diff --git a/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java b/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java
index a06de536a2f..1903337108b 100644
--- a/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java
@@ -27,8 +27,8 @@ import org.apache.druid.jackson.DefaultObjectMapper;
import org.apache.druid.storage.StorageConfig;
import org.apache.druid.storage.StorageConnectorModule;
import org.apache.druid.storage.local.LocalFileExportStorageProvider;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -61,6 +61,6 @@ public class ExportDestinationTest
byte[] bytes = objectMapper.writeValueAsBytes(exportDestination);
ExportDestination deserialized = objectMapper.readValue(bytes, ExportDestination.class);
- Assert.assertEquals(exportDestination, deserialized);
+ Assertions.assertEquals(exportDestination, deserialized);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java b/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java
index 7af4ad2eb4d..0f76cfb9f1e 100644
--- a/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.sql.destination;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.druid.jackson.DefaultObjectMapper;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -37,6 +37,6 @@ public class TableDestinationTest
byte[] bytes = objectMapper.writeValueAsBytes(tableDestination);
TableDestination deserialized = objectMapper.readValue(bytes, TableDestination.class);
- Assert.assertEquals(tableDestination, deserialized);
+ Assertions.assertEquals(tableDestination, deserialized);
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
index e04032a6637..b1154ebb977 100644
--- a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java
@@ -74,19 +74,20 @@ import org.apache.druid.sql.calcite.view.NoopViewManager;
import org.apache.druid.sql.calcite.view.ViewManager;
import org.apache.druid.sql.http.SqlResourceTest;
import org.easymock.EasyMock;
-import org.easymock.EasyMockRunner;
+import org.easymock.EasyMockExtension;
import org.easymock.Mock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import javax.validation.Validation;
import javax.validation.Validator;
+
import java.util.Map;
import java.util.Properties;
-@RunWith(EasyMockRunner.class)
+@ExtendWith(EasyMockExtension.class)
public class SqlModuleTest
{
@Mock
@@ -130,7 +131,7 @@ public class SqlModuleTest
private Injector injector;
- @Before
+ @BeforeEach
public void setUp()
{
EasyMock.replay(
@@ -160,8 +161,8 @@ public class SqlModuleTest
injector = makeInjectorWithProperties(props);
ViewManager viewManager = injector.getInstance(Key.get(ViewManager.class));
- Assert.assertNotNull(viewManager);
- Assert.assertTrue(viewManager instanceof NoopViewManager);
+ Assertions.assertNotNull(viewManager);
+ Assertions.assertTrue(viewManager instanceof NoopViewManager);
}
@Test
@@ -176,8 +177,8 @@ public class SqlModuleTest
injector = makeInjectorWithProperties(props);
ViewManager viewManager = injector.getInstance(Key.get(ViewManager.class));
- Assert.assertNotNull(viewManager);
- Assert.assertTrue(viewManager instanceof BindTestViewManager);
+ Assertions.assertNotNull(viewManager);
+ Assertions.assertTrue(viewManager instanceof BindTestViewManager);
}
private Injector makeInjectorWithProperties(final Properties props)
diff --git a/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java b/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java
index 37ee6de032a..a270b176373 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java
@@ -23,7 +23,7 @@ import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.druid.jackson.DefaultObjectMapper;
import org.apache.druid.java.util.common.StringUtils;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
@@ -39,17 +39,17 @@ public class ResultFormatTest
public void testSerde(ResultFormat target) throws JsonProcessingException
{
final String json = jsonMapper.writeValueAsString(target);
- Assert.assertEquals(StringUtils.format("\"%s\"", target.toString()), json);
- Assert.assertEquals(target, jsonMapper.readValue(json, ResultFormat.class));
+ Assertions.assertEquals(StringUtils.format("\"%s\"", target.toString()), json);
+ Assertions.assertEquals(target, jsonMapper.readValue(json, ResultFormat.class));
}
@Test
public void testDeserializeWithDifferentCase() throws JsonProcessingException
{
- Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"OBJECTLINES\"", ResultFormat.class));
- Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectLines\"", ResultFormat.class));
- Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectlines\"", ResultFormat.class));
- Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"oBjEcTlInEs\"", ResultFormat.class));
+ Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"OBJECTLINES\"", ResultFormat.class));
+ Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectLines\"", ResultFormat.class));
+ Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectlines\"", ResultFormat.class));
+ Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"oBjEcTlInEs\"", ResultFormat.class));
}
public static Object[] provideResultFormats()
diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java
index 87a501f00a8..67d6033a241 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java
@@ -39,17 +39,17 @@ import org.apache.druid.server.security.AuthorizerMapper;
import org.apache.druid.sql.SqlStatementFactory;
import org.apache.druid.sql.calcite.run.NativeSqlEngine;
import org.easymock.EasyMock;
-import org.easymock.EasyMockRunner;
+import org.easymock.EasyMockExtension;
import org.easymock.Mock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Collections;
import java.util.Set;
-@RunWith(EasyMockRunner.class)
+@ExtendWith(EasyMockExtension.class)
public class SqlHttpModuleTest
{
@Mock
@@ -58,7 +58,7 @@ public class SqlHttpModuleTest
private SqlHttpModule target;
private Injector injector;
- @Before
+ @BeforeEach
public void setUp()
{
target = new SqlHttpModule();
@@ -85,9 +85,9 @@ public class SqlHttpModuleTest
public void testSqlResourceIsInjectedAndSingleton()
{
SqlResource sqlResource = injector.getInstance(SqlResource.class);
- Assert.assertNotNull(sqlResource);
+ Assertions.assertNotNull(sqlResource);
SqlResource other = injector.getInstance(SqlResource.class);
- Assert.assertSame(other, sqlResource);
+ Assertions.assertSame(other, sqlResource);
}
@Test
@@ -95,7 +95,7 @@ public class SqlHttpModuleTest
{
Set<Class<?>> jerseyResourceClasses =
injector.getInstance(Key.get(new TypeLiteral<>() {}, JSR311Resource.class));
- Assert.assertEquals(1, jerseyResourceClasses.size());
- Assert.assertEquals(SqlResource.class, jerseyResourceClasses.iterator().next());
+ Assertions.assertEquals(1, jerseyResourceClasses.size());
+ Assertions.assertEquals(SqlResource.class, jerseyResourceClasses.iterator().next());
}
}
diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java
index 90aac37aa45..52d16d9787e 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java
@@ -23,11 +23,12 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.druid.jackson.DefaultObjectMapper;
import org.apache.druid.server.initialization.jetty.HttpException;
import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.core.Response;
+
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
@@ -45,7 +46,7 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT 1", result.getQuery());
+ Assertions.assertEquals("SELECT 1", result.getQuery());
}
@Test
@@ -56,7 +57,7 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT 2", result.getQuery());
+ Assertions.assertEquals("SELECT 2", result.getQuery());
}
@Test
@@ -67,7 +68,7 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT 3", result.getQuery());
+ Assertions.assertEquals("SELECT 3", result.getQuery());
}
@Test
@@ -78,7 +79,7 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT 4", result.getQuery());
+ Assertions.assertEquals("SELECT 4", result.getQuery());
}
@Test
@@ -89,7 +90,7 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT 5", result.getQuery());
+ Assertions.assertEquals("SELECT 5", result.getQuery());
}
@Test
@@ -100,7 +101,7 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT 6", result.getQuery());
+ Assertions.assertEquals("SELECT 6", result.getQuery());
}
@Test
@@ -111,7 +112,7 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT 7", result.getQuery());
+ Assertions.assertEquals("SELECT 7", result.getQuery());
}
@Test
@@ -120,13 +121,13 @@ public class SqlQueryTest
String content = "SELECT 8";
HttpServletRequest request = createMockRequest(null, content);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
- Assert.assertEquals("Missing Content-Type header", exception.getMessage());
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertEquals("Missing Content-Type header", exception.getMessage());
}
@Test
@@ -135,14 +136,14 @@ public class SqlQueryTest
String xmlQuery = "<query>SELECT 9</query>";
HttpServletRequest request = createMockRequest("application/xml", xmlQuery);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
- Assert.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
- Assert.assertTrue(exception.getMessage().contains("application/xml"));
+ Assertions.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
+ Assertions.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
+ Assertions.assertTrue(exception.getMessage().contains("application/xml"));
}
@Test
@@ -151,14 +152,14 @@ public class SqlQueryTest
String xmlQuery = "<query>SELECT 10</query>";
HttpServletRequest request = createMockRequest("application/xml; charset=UTF-8", xmlQuery);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
- Assert.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
- Assert.assertTrue(exception.getMessage().contains("application/xml"));
+ Assertions.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode());
+ Assertions.assertTrue(exception.getMessage().contains("Unsupported Content-Type"));
+ Assertions.assertTrue(exception.getMessage().contains("application/xml"));
}
@Test
@@ -167,13 +168,13 @@ public class SqlQueryTest
String content = "SELECT 11";
HttpServletRequest request = createMockRequest("invalid-content-type-format", content);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
- Assert.assertTrue(exception.getMessage().contains("Invalid Content-Type header"));
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertTrue(exception.getMessage().contains("Invalid Content-Type header"));
}
@Test
@@ -182,13 +183,13 @@ public class SqlQueryTest
String jsonQuery = "{}";
HttpServletRequest request = createMockRequest("application/json", jsonQuery);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
- Assert.assertTrue(exception.getMessage()
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertTrue(exception.getMessage()
.contains("Unable to read query from request: Cannot construct instance of "));
}
@@ -198,12 +199,12 @@ public class SqlQueryTest
String jsonQuery = "{\"query\": null}";
HttpServletRequest request = createMockRequest("application/json", jsonQuery);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
}
@Test
@@ -212,13 +213,13 @@ public class SqlQueryTest
String textQuery = "";
HttpServletRequest request = createMockRequest("text/plain", textQuery);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
- Assert.assertEquals("Empty query", exception.getMessage());
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertEquals("Empty query", exception.getMessage());
}
@Test
@@ -227,13 +228,13 @@ public class SqlQueryTest
String textQuery = " \n\t ";
HttpServletRequest request = createMockRequest("text/plain", textQuery);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
- Assert.assertEquals("Empty query", exception.getMessage());
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertEquals("Empty query", exception.getMessage());
}
@Test
@@ -242,13 +243,13 @@ public class SqlQueryTest
String formQuery = "";
HttpServletRequest request = createMockRequest("application/x-www-form-urlencoded", formQuery);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
- Assert.assertEquals("Empty query", exception.getMessage());
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertEquals("Empty query", exception.getMessage());
}
@@ -258,13 +259,13 @@ public class SqlQueryTest
String malformedJson = "{\"query\":\"SELECT 12\""; // Missing closing brace
HttpServletRequest request = createMockRequest("application/json", malformedJson);
- HttpException exception = Assert.assertThrows(
+ HttpException exception = Assertions.assertThrows(
HttpException.class,
() -> SqlQuery.from(request, objectMapper)
);
- Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
- Assert.assertTrue(exception.getMessage().contains("Malformed SQL query wrapped in JSON: Unexpected end-of-input:"));
+ Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode());
+ Assertions.assertTrue(exception.getMessage().contains("Malformed SQL query wrapped in JSON: Unexpected end-of-input:"));
}
@Test
@@ -275,16 +276,16 @@ public class SqlQueryTest
HttpServletRequest request1 = createMockRequest("APPLICATION/JSON", jsonQuery);
SqlQuery result1 = SqlQuery.from(request1, objectMapper);
- Assert.assertEquals("SELECT 13", result1.getQuery());
+ Assertions.assertEquals("SELECT 13", result1.getQuery());
HttpServletRequest request2 = createMockRequest("Application/Json; Charset=UTF-8", jsonQuery);
SqlQuery result2 = SqlQuery.from(request2, objectMapper);
- Assert.assertEquals("SELECT 13", result2.getQuery());
+ Assertions.assertEquals("SELECT 13", result2.getQuery());
String textQuery = "SELECT 14";
HttpServletRequest request3 = createMockRequest("TEXT/PLAIN", textQuery);
SqlQuery result3 = SqlQuery.from(request3, objectMapper);
- Assert.assertEquals("SELECT 14", result3.getQuery());
+ Assertions.assertEquals("SELECT 14", result3.getQuery());
}
@Test
@@ -295,9 +296,9 @@ public class SqlQueryTest
SqlQuery result = SqlQuery.from(request, objectMapper);
- Assert.assertEquals("SELECT COUNT(*) FROM table WHERE col > 100", result.getQuery());
- Assert.assertTrue(result.includeHeader());
- Assert.assertNotNull(result.getContext());
+ Assertions.assertEquals("SELECT COUNT(*) FROM table WHERE col > 100", result.getQuery());
+ Assertions.assertTrue(result.includeHeader());
+ Assertions.assertNotNull(result.getContext());
}
diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
index 6fb974a527c..3fa5243fc8b 100644
--- a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java
@@ -105,10 +105,9 @@ import org.apache.druid.sql.calcite.schema.DruidSchemaCatalog;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
import org.apache.druid.sql.calcite.util.CalciteTests;
import org.apache.druid.sql.hook.DruidHookDispatcher;
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -121,6 +120,7 @@ import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.StreamingOutput;
+
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
@@ -357,12 +357,12 @@ public class SqlResourceTest extends CalciteTestBase
@Test
public void testUnauthorized()
{
- ForbiddenException e = Assert.assertThrows(ForbiddenException.class, () -> {
+ ForbiddenException e = Assertions.assertThrows(ForbiddenException.class, () -> {
postForAsyncResponse(createSimpleQueryWithId("id", "select count(*) from forbiddenDatasource"), request());
});
- Assert.assertEquals("Unauthorized", e.getMessage());
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertEquals("Unauthorized", e.getMessage());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
@Test
@@ -373,21 +373,21 @@ public class SqlResourceTest extends CalciteTestBase
"id",
"select count(*) as cnt from restrictedDatasource_m1_is_6"
)).rhs;
- Assert.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 6)), resultAsSuperUser);
+ Assertions.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 6)), resultAsSuperUser);
checkSqlRequestLog(true, CalciteTests.TEST_SUPERUSER_NAME);
testRequestLogger.clear();
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
req = makeRegularUserReq();
final List<Map<String, Object>> resultAsRegularUser = doPost(createSimpleQueryWithId(
"id",
"select count(*) as cnt from restrictedDatasource_m1_is_6"
)).rhs;
- Assert.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 1)), resultAsRegularUser);
+ Assertions.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 1)), resultAsRegularUser);
checkSqlRequestLog(true);
testRequestLogger.clear();
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
@Test
@@ -397,16 +397,16 @@ public class SqlResourceTest extends CalciteTestBase
createSimpleQueryWithId("id", "SELECT COUNT(*) AS cnt, 'foo' AS TheFoo FROM druid.foo")
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 6, "TheFoo", "foo")
),
rows
);
checkSqlRequestLog(true);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -414,7 +414,7 @@ public class SqlResourceTest extends CalciteTestBase
{
Response response = resource.getSupportedEngines(req);
Set<EngineInfo> supportedEngines = ((SupportedEnginesResponse) response.getEntity()).getEngines();
- Assert.assertTrue(supportedEngines.contains(new EngineInfo(NativeSqlEngine.NAME)));
+ Assertions.assertTrue(supportedEngines.contains(new EngineInfo(NativeSqlEngine.NAME)));
}
@Test
@@ -462,18 +462,18 @@ public class SqlResourceTest extends CalciteTestBase
})
.collect(Collectors.toList());
- Assert.assertEquals(expectedMissingHeaders, observedMissingHeaders);
+ Assertions.assertEquals(expectedMissingHeaders, observedMissingHeaders);
Object results = JSON_MAPPER.readValue(response.baos.toByteArray(), Object.class);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 6, "TheFoo", "foo")
),
results
);
checkSqlRequestLog(true);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
@Test
@@ -483,18 +483,18 @@ public class SqlResourceTest extends CalciteTestBase
createSimpleQueryWithId("id", "SELECT COUNT(*) AS cnt, 'foo' AS TheFoo FROM druid.foo")
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 6, "TheFoo", "foo")
),
rows
);
checkSqlRequestLog(true);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
stubServiceEmitter.verifyValue("sqlQuery/bytes", 27L);
stubServiceEmitter.verifyEmitted("sqlQuery/planningTimeMs", 1);
- Assert.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@@ -508,14 +508,14 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("cnt", 1)
),
rows
);
checkSqlRequestLog(true);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
@Test
@@ -533,7 +533,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("__time", "2000-01-01T00:00:00.000Z", "t2", "2000-01-01T00:00:00.000Z")
),
@@ -556,7 +556,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("__time", "2000-01-01T00:00:00.000Z", "t2", "2000-01-01T00:00:00.000Z")
),
@@ -579,7 +579,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("__time", "1999-12-31T16:00:00.000-08:00", "t2", "1999-12-31T00:00:00.000-08:00")
),
@@ -622,7 +622,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("__time", "1999-12-31T16:00:00.000-08:00", "t2", "1999-12-31T00:00:00.000-08:00")
),
@@ -645,7 +645,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
Maps.transformValues(
ImmutableMap.of("t1", "2001-01-03T00:00:00.000Z", "t2", ""),
@@ -671,7 +671,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("x", "a", "y", "a")
),
@@ -694,7 +694,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
// x and y both should be null instead of empty string
Maps.transformValues(ImmutableMap.of("x", "", "y", ""), (val) -> null),
@@ -746,7 +746,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("Age", "18-19", "Women", 0.040737148399612025, "Men", 0.1052376333656644),
ImmutableMap.of("Age", "20-29", "Women", 0.1556741028128031, "Men", 0.3976721629485936),
@@ -797,7 +797,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.of("Age", "18-19", "Women", 0.040737148399612025, "Men", 0.1052376333656644),
ImmutableMap.of("Age", "20-29", "Women", 0.1556741028128031, "Men", 0.3976721629485936),
@@ -814,7 +814,7 @@ public class SqlResourceTest extends CalciteTestBase
{
final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2";
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
Arrays.asList(
"2000-01-01T00:00:00.000Z",
@@ -858,8 +858,8 @@ public class SqlResourceTest extends CalciteTestBase
doPostRaw(new SqlQuery(query, ResultFormat.ARRAY, false, false, false, null, null), req);
// Truncated response: missing final ]
- Assert.assertNull(response.lhs);
- Assert.assertEquals("[[1],[1]", response.rhs);
+ Assertions.assertNull(response.lhs);
+ Assertions.assertEquals("[[1],[1]", response.rhs);
}
@Test
@@ -872,8 +872,8 @@ public class SqlResourceTest extends CalciteTestBase
doPostRaw(new SqlQuery(query, ResultFormat.OBJECT, false, false, false, null, null), req);
// Truncated response: missing final ]
- Assert.assertNull(response.lhs);
- Assert.assertEquals("[{\"cnt\":1},{\"cnt\":1}", response.rhs);
+ Assertions.assertNull(response.lhs);
+ Assertions.assertEquals("[{\"cnt\":1},{\"cnt\":1}", response.rhs);
}
@Test
@@ -886,8 +886,8 @@ public class SqlResourceTest extends CalciteTestBase
doPostRaw(new SqlQuery(query, ResultFormat.ARRAYLINES, false, false, false, null, null), req);
// Truncated response: missing final LFLF
- Assert.assertNull(response.lhs);
- Assert.assertEquals("[1]\n[1]", response.rhs);
+ Assertions.assertNull(response.lhs);
+ Assertions.assertEquals("[1]\n[1]", response.rhs);
}
@Test
@@ -900,8 +900,8 @@ public class SqlResourceTest extends CalciteTestBase
doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, false, false, false, null, null), req);
// Truncated response: missing final LFLF
- Assert.assertNull(response.lhs);
- Assert.assertEquals("{\"cnt\":1}\n{\"cnt\":1}", response.rhs);
+ Assertions.assertNull(response.lhs);
+ Assertions.assertEquals("{\"cnt\":1}\n{\"cnt\":1}", response.rhs);
}
@Test
@@ -914,8 +914,8 @@ public class SqlResourceTest extends CalciteTestBase
doPostRaw(new SqlQuery(query, ResultFormat.CSV, false, false, false, null, null), req);
// Truncated response: missing final LFLF
- Assert.assertNull(response.lhs);
- Assert.assertEquals("1\n1\n", response.rhs);
+ Assertions.assertNull(response.lhs);
+ Assertions.assertEquals("1\n1\n", response.rhs);
}
@Test
@@ -934,9 +934,9 @@ public class SqlResourceTest extends CalciteTestBase
req.mimic()
);
- Assert.assertEquals(200, response.getStatus());
- Assert.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
- Assert.assertEquals(
+ Assertions.assertEquals(200, response.getStatus());
+ Assertions.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
+ Assertions.assertEquals(
ImmutableList.builder()
.add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
.add(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS)
@@ -951,9 +951,9 @@ public class SqlResourceTest extends CalciteTestBase
req.mimic()
);
- Assert.assertEquals(200, responseNoSqlTypesHeader.getStatus());
- Assert.assertEquals("yes", responseNoSqlTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
- Assert.assertEquals(
+ Assertions.assertEquals(200, responseNoSqlTypesHeader.getStatus());
+ Assertions.assertEquals("yes", responseNoSqlTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
+ Assertions.assertEquals(
ImmutableList.builder()
.add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
.add(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS)
@@ -967,9 +967,9 @@ public class SqlResourceTest extends CalciteTestBase
req.mimic()
);
- Assert.assertEquals(200, responseNoTypesHeader.getStatus());
- Assert.assertEquals("yes", responseNoTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
- Assert.assertEquals(
+ Assertions.assertEquals(200, responseNoTypesHeader.getStatus());
+ Assertions.assertEquals("yes", responseNoTypesHeader.getHeader("X-Druid-SQL-Header-Included"));
+ Assertions.assertEquals(
ImmutableList.builder()
.add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
.add(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS)
@@ -983,9 +983,9 @@ public class SqlResourceTest extends CalciteTestBase
req.mimic()
);
- Assert.assertEquals(200, responseNoTypes.getStatus());
- Assert.assertEquals("yes", responseNoTypes.getHeader("X-Druid-SQL-Header-Included"));
- Assert.assertEquals(
+ Assertions.assertEquals(200, responseNoTypes.getStatus());
+ Assertions.assertEquals("yes", responseNoTypes.getHeader("X-Druid-SQL-Header-Included"));
+ Assertions.assertEquals(
ImmutableList.builder()
.add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS)
.addAll(Arrays.asList(expectedQueryResults))
@@ -998,9 +998,9 @@ public class SqlResourceTest extends CalciteTestBase
req.mimic()
);
- Assert.assertEquals(200, responseNoHeader.getStatus());
- Assert.assertNull(responseNoHeader.getHeader("X-Druid-SQL-Header-Included"));
- Assert.assertEquals(
+ Assertions.assertEquals(200, responseNoHeader.getStatus());
+ Assertions.assertNull(responseNoHeader.getHeader("X-Druid-SQL-Header-Included"));
+ Assertions.assertEquals(
Arrays.asList(expectedQueryResults),
JSON_MAPPER.readValue(responseNoHeader.baos.toByteArray(), Object.class)
);
@@ -1018,10 +1018,10 @@ public class SqlResourceTest extends CalciteTestBase
req
);
- Assert.assertEquals(200, response.getStatus());
- Assert.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
+ Assertions.assertEquals(200, response.getStatus());
+ Assertions.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included"));
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
Collections.singletonList("EXPR$0"),
Collections.singletonList(null),
@@ -1044,12 +1044,12 @@ public class SqlResourceTest extends CalciteTestBase
final Pair<ErrorResponse, String> pair = doPostRaw(
new SqlQuery(query, ResultFormat.ARRAYLINES, false, false, false, null, null)
);
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final List<String> lines = Splitter.on('\n').splitToList(response);
- Assert.assertEquals(4, lines.size());
- Assert.assertEquals(
+ Assertions.assertEquals(4, lines.size());
+ Assertions.assertEquals(
Arrays.asList(
"2000-01-01T00:00:00.000Z",
"",
@@ -1063,7 +1063,7 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(0), List.class)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Arrays.asList(
"2000-01-02T00:00:00.000Z",
"10.1",
@@ -1077,8 +1077,8 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(1), List.class)
);
- Assert.assertEquals("", lines.get(2));
- Assert.assertEquals("", lines.get(3));
+ Assertions.assertEquals("", lines.get(2));
+ Assertions.assertEquals("", lines.get(3));
}
@Test
@@ -1088,15 +1088,15 @@ public class SqlResourceTest extends CalciteTestBase
final Pair<ErrorResponse, String> pair = doPostRaw(
new SqlQuery(query, ResultFormat.ARRAYLINES, true, true, true, null, null)
);
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final List<String> lines = Splitter.on('\n').splitToList(response);
- Assert.assertEquals(7, lines.size());
- Assert.assertEquals(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(0), List.class));
- Assert.assertEquals(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(1), List.class));
- Assert.assertEquals(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(2), List.class));
- Assert.assertEquals(
+ Assertions.assertEquals(7, lines.size());
+ Assertions.assertEquals(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(0), List.class));
+ Assertions.assertEquals(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(1), List.class));
+ Assertions.assertEquals(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(2), List.class));
+ Assertions.assertEquals(
Arrays.asList(
"2000-01-01T00:00:00.000Z",
"",
@@ -1110,7 +1110,7 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(3), List.class)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
Arrays.asList(
"2000-01-02T00:00:00.000Z",
"10.1",
@@ -1124,8 +1124,8 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(4), List.class)
);
- Assert.assertEquals("", lines.get(5));
- Assert.assertEquals("", lines.get(6));
+ Assertions.assertEquals("", lines.get(5));
+ Assertions.assertEquals("", lines.get(6));
}
@Test
@@ -1135,15 +1135,15 @@ public class SqlResourceTest extends CalciteTestBase
final Pair<ErrorResponse, String> pair = doPostRaw(
new SqlQuery(query, ResultFormat.ARRAYLINES, true, true, true, null, null)
);
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final List<String> lines = Splitter.on('\n').splitToList(response);
- Assert.assertEquals(6, lines.size());
- Assert.assertEquals(Collections.singletonList("EXPR$0"), JSON_MAPPER.readValue(lines.get(0), List.class));
- Assert.assertEquals(Collections.singletonList(null), JSON_MAPPER.readValue(lines.get(1), List.class));
- Assert.assertEquals(Collections.singletonList("ROW"), JSON_MAPPER.readValue(lines.get(2), List.class));
- Assert.assertEquals(
+ Assertions.assertEquals(6, lines.size());
+ Assertions.assertEquals(Collections.singletonList("EXPR$0"), JSON_MAPPER.readValue(lines.get(0), List.class));
+ Assertions.assertEquals(Collections.singletonList(null), JSON_MAPPER.readValue(lines.get(1), List.class));
+ Assertions.assertEquals(Collections.singletonList("ROW"), JSON_MAPPER.readValue(lines.get(2), List.class));
+ Assertions.assertEquals(
Collections.singletonList(
Arrays.asList(
1,
@@ -1152,8 +1152,8 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(3), List.class)
);
- Assert.assertEquals("", lines.get(4));
- Assert.assertEquals("", lines.get(5));
+ Assertions.assertEquals("", lines.get(4));
+ Assertions.assertEquals("", lines.get(5));
}
@Test
@@ -1165,7 +1165,7 @@ public class SqlResourceTest extends CalciteTestBase
(k, v) -> "EXPR$8".equals(k) || ("dim2".equals(k) && v.toString().isEmpty()) ? null : v
);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap
.<String, Object>builder()
@@ -1208,7 +1208,7 @@ public class SqlResourceTest extends CalciteTestBase
final Pair<ErrorResponse, String> pair = doPostRaw(
new SqlQuery(query, ResultFormat.OBJECTLINES, false, false, false, null, null)
);
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final Function<Map<String, Object>, Map<String, Object>> transformer = m -> {
return Maps.transformEntries(
@@ -1218,8 +1218,8 @@ public class SqlResourceTest extends CalciteTestBase
};
final List<String> lines = Splitter.on('\n').splitToList(response);
- Assert.assertEquals(4, lines.size());
- Assert.assertEquals(
+ Assertions.assertEquals(4, lines.size());
+ Assertions.assertEquals(
transformer.apply(
ImmutableMap
.<String, Object>builder()
@@ -1236,7 +1236,7 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(0), Object.class)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
transformer.apply(
ImmutableMap
.<String, Object>builder()
@@ -1253,8 +1253,8 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(1), Object.class)
);
- Assert.assertEquals("", lines.get(2));
- Assert.assertEquals("", lines.get(3));
+ Assertions.assertEquals("", lines.get(2));
+ Assertions.assertEquals("", lines.get(3));
}
@Test
@@ -1263,7 +1263,7 @@ public class SqlResourceTest extends CalciteTestBase
final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2";
final Pair<ErrorResponse, String> pair =
doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, false, false, null, null));
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final Function<Map<String, Object>, Map<String, Object>> transformer = m -> Maps.transformEntries(
m,
@@ -1276,9 +1276,9 @@ public class SqlResourceTest extends CalciteTestBase
expectedHeader.put(column, null);
}
- Assert.assertEquals(5, lines.size());
- Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
- Assert.assertEquals(
+ Assertions.assertEquals(5, lines.size());
+ Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
+ Assertions.assertEquals(
transformer.apply(
ImmutableMap
.<String, Object>builder()
@@ -1295,7 +1295,7 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(1), Object.class)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
transformer.apply(
ImmutableMap
.<String, Object>builder()
@@ -1312,8 +1312,8 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(2), Object.class)
);
- Assert.assertEquals("", lines.get(3));
- Assert.assertEquals("", lines.get(4));
+ Assertions.assertEquals("", lines.get(3));
+ Assertions.assertEquals("", lines.get(4));
}
@Test
@@ -1322,7 +1322,7 @@ public class SqlResourceTest extends CalciteTestBase
final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2";
final Pair<ErrorResponse, String> pair =
doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, true, true, null, null));
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final Function<Map<String, Object>, Map<String, Object>> transformer = m -> Maps.transformEntries(
m,
@@ -1341,9 +1341,9 @@ public class SqlResourceTest extends CalciteTestBase
);
}
- Assert.assertEquals(5, lines.size());
- Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
- Assert.assertEquals(
+ Assertions.assertEquals(5, lines.size());
+ Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
+ Assertions.assertEquals(
transformer.apply(
ImmutableMap
.<String, Object>builder()
@@ -1360,7 +1360,7 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(1), Object.class)
);
- Assert.assertEquals(
+ Assertions.assertEquals(
transformer.apply(
ImmutableMap
.<String, Object>builder()
@@ -1377,8 +1377,8 @@ public class SqlResourceTest extends CalciteTestBase
),
JSON_MAPPER.readValue(lines.get(2), Object.class)
);
- Assert.assertEquals("", lines.get(3));
- Assert.assertEquals("", lines.get(4));
+ Assertions.assertEquals("", lines.get(3));
+ Assertions.assertEquals("", lines.get(4));
}
@Test
@@ -1387,7 +1387,7 @@ public class SqlResourceTest extends CalciteTestBase
final String query = "SELECT (1, 2) FROM INFORMATION_SCHEMA.COLUMNS LIMIT 1";
final Pair<ErrorResponse, String> pair =
doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, true, true, null, null));
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final List<String> lines = Splitter.on('\n').splitToList(response);
@@ -1396,9 +1396,9 @@ public class SqlResourceTest extends CalciteTestBase
typeMap.put(ObjectWriter.SQL_TYPE_HEADER_NAME, "ROW");
final Map<String, Object> expectedHeader = ImmutableMap.of("EXPR$0", typeMap);
- Assert.assertEquals(4, lines.size());
- Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
- Assert.assertEquals(
+ Assertions.assertEquals(4, lines.size());
+ Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class));
+ Assertions.assertEquals(
ImmutableMap
.<String, Object>builder()
.put("EXPR$0", Arrays.asList(1, 2))
@@ -1406,8 +1406,8 @@ public class SqlResourceTest extends CalciteTestBase
JSON_MAPPER.readValue(lines.get(1), Object.class)
);
- Assert.assertEquals("", lines.get(2));
- Assert.assertEquals("", lines.get(3));
+ Assertions.assertEquals("", lines.get(2));
+ Assertions.assertEquals("", lines.get(3));
}
@Test
@@ -1417,11 +1417,11 @@ public class SqlResourceTest extends CalciteTestBase
final Pair<ErrorResponse, String> pair = doPostRaw(
new SqlQuery(query, ResultFormat.CSV, false, false, false, null, null)
);
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final List<String> lines = Splitter.on('\n').splitToList(response);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
"2000-01-01T00:00:00.000Z,,a,\"[\"\"a\"\",\"\"b\"\"]\",1,1.0,1.0,\"\"\"AQAAAEAAAA==\"\"\",",
"2000-01-02T00:00:00.000Z,10.1,,\"[\"\"b\"\",\"\"c\"\"]\",1,2.0,2.0,\"\"\"AQAAAQAAAAHNBA==\"\"\",",
@@ -1439,11 +1439,11 @@ public class SqlResourceTest extends CalciteTestBase
final Pair<ErrorResponse, String> pair = doPostRaw(
new SqlQuery(query, ResultFormat.CSV, true, true, true, null, null)
);
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final List<String> lines = Splitter.on('\n').splitToList(response);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
String.join(",", EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS),
String.join(",", EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS),
@@ -1464,11 +1464,11 @@ public class SqlResourceTest extends CalciteTestBase
final Pair<ErrorResponse, String> pair = doPostRaw(
new SqlQuery(query, ResultFormat.CSV, true, true, true, null, null)
);
- Assert.assertNull(pair.lhs);
+ Assertions.assertNull(pair.lhs);
final String response = pair.rhs;
final List<String> lines = Splitter.on('\n').splitToList(response);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
"EXPR$0",
"",
@@ -1499,7 +1499,7 @@ public class SqlResourceTest extends CalciteTestBase
)
).rhs;
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(
ImmutableMap.<String, Object>of(
"PLAN",
@@ -1528,8 +1528,8 @@ public class SqlResourceTest extends CalciteTestBase
errorResponse,
"Incorrect syntax near the keyword 'FROM' at line 1, column 1"
);
- Assert.assertEquals(0, testRequestLogger.getSqlQueryLogs().size()); // Invalid queries are not logged
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertEquals(0, testRequestLogger.getSqlQueryLogs().size()); // Invalid queries are not logged
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
@Test
@@ -1545,9 +1545,9 @@ public class SqlResourceTest extends CalciteTestBase
"Column 'dim4' not found in any table"
);
checkSqlRequestLog(false);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -1557,7 +1557,7 @@ public class SqlResourceTest extends CalciteTestBase
final SqlQuery unsupportedQuery = createSimpleQueryWithId("id", "SELECT dim1 FROM druid.foo ORDER BY dim1");
ErrorResponse exception = postSyncForException(unsupportedQuery, Status.BAD_REQUEST.getStatusCode());
- Assert.assertTrue((Boolean) req.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED));
+ Assertions.assertTrue((Boolean) req.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED));
validateErrorResponse(
exception,
@@ -1568,9 +1568,9 @@ public class SqlResourceTest extends CalciteTestBase
+ "[SQL query requires ordering a table by non-time column [[dim1]], which is not supported.]"
);
checkSqlRequestLog(false);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
/**
@@ -1592,9 +1592,9 @@ public class SqlResourceTest extends CalciteTestBase
"Aggregation [MAX] does not support type [STRING], column [v0]"
);
checkSqlRequestLog(false);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -1618,7 +1618,7 @@ public class SqlResourceTest extends CalciteTestBase
ResourceLimitExceededException.class.getName(),
""
);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
private void failOnExecute(String errorMessage)
@@ -1647,7 +1647,7 @@ public class SqlResourceTest extends CalciteTestBase
);
validateInvalidSqlError(exception, "Incorrect syntax near the keyword 'TO'");
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
@Test
@@ -1672,8 +1672,8 @@ public class SqlResourceTest extends CalciteTestBase
// This is checked in the common method that returns the response, but checking it again just protects
// from changes there breaking the checks, so doesn't hurt.
assertStatusAndCommonHeaders(response, DruidException.Category.INVALID_INPUT.getExpectedStatus());
- Assert.assertEquals(queryId, getHeader(response, QueryResource.QUERY_ID_RESPONSE_HEADER));
- Assert.assertEquals(queryId, getHeader(response, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
+ Assertions.assertEquals(queryId, getHeader(response, QueryResource.QUERY_ID_RESPONSE_HEADER));
+ Assertions.assertEquals(queryId, getHeader(response, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
}
@Test
@@ -1694,8 +1694,8 @@ public class SqlResourceTest extends CalciteTestBase
final Response response = resource.doPost(sqlQuery, req);
// Query ID won't be set, but we can look for other aspects of the response that we expect.
- Assert.assertEquals(DruidException.Category.INVALID_INPUT.getExpectedStatus(), response.getStatus());
- Assert.assertEquals("application/json", getContentType(response));
+ Assertions.assertEquals(DruidException.Category.INVALID_INPUT.getExpectedStatus(), response.getStatus());
+ Assertions.assertEquals("application/json", getContentType(response));
}
@Test
@@ -1749,7 +1749,7 @@ public class SqlResourceTest extends CalciteTestBase
"org.apache.druid.query.QueryUnsupportedException",
"This will be supported in Druid 9999"
);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
}
/**
@@ -1785,9 +1785,9 @@ public class SqlResourceTest extends CalciteTestBase
.invalidSqlInput()
.expectMessageIs("Calcite assertion violated: [not a literal: assertion_error()]")
);
- Assert.assertTrue(lifecycleManager.getAll("id").isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -1864,8 +1864,8 @@ public class SqlResourceTest extends CalciteTestBase
Response response = (Response) futures.get(i).get();
assertStatusAndCommonHeaders(response, 429);
QueryException interruped = deserializeResponse(response, QueryException.class);
- Assert.assertEquals(QueryException.QUERY_CAPACITY_EXCEEDED_ERROR_CODE, interruped.getErrorCode());
- Assert.assertEquals(
+ Assertions.assertEquals(QueryException.QUERY_CAPACITY_EXCEEDED_ERROR_CODE, interruped.getErrorCode());
+ Assertions.assertEquals(
QueryCapacityExceededException.makeLaneErrorMessage(HiLoQueryLaningStrategy.LOW, 2),
interruped.getMessage()
);
@@ -1873,17 +1873,17 @@ public class SqlResourceTest extends CalciteTestBase
} else {
MockHttpServletResponse response = (MockHttpServletResponse) futures.get(i).get();
assertStatusAndCommonHeaders(response, 200);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableList.of(ImmutableMap.of("cnt", 6, "TheFoo", "foo")),
deserializeResponse(response, Object.class)
);
success++;
}
}
- Assert.assertEquals(2, success);
- Assert.assertEquals(1, limited);
- Assert.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
- Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+ Assertions.assertEquals(2, success);
+ Assertions.assertEquals(1, limited);
+ Assertions.assertEquals(3, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 3);
Map<Integer, Long> codeFrequencies = stubServiceEmitter.getMetricEvents("sqlQuery/time").stream()
.map(event -> event.toMap())
@@ -1892,7 +1892,7 @@ public class SqlResourceTest extends CalciteTestBase
code -> code,
Collectors.counting()
));
- Assert.assertEquals(Map.of(200, 2L, 429, 1L), codeFrequencies);
+ Assertions.assertEquals(Map.of(200, 2L, 429, 1L), codeFrequencies);
}
@Test
@@ -1925,9 +1925,9 @@ public class SqlResourceTest extends CalciteTestBase
QueryTimeoutException.class.getName(),
""
);
- Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(504, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(504, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -1945,13 +1945,13 @@ public class SqlResourceTest extends CalciteTestBase
makeRegularUserReq()
)
);
- Assert.assertTrue(validateAndAuthorizeLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
- Assert.assertTrue(lifecycleAddLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(validateAndAuthorizeLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(lifecycleAddLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel());
planLatch.countDown();
- Assert.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
+ Assertions.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
- Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
Response queryResponse = future.get();
assertStatusAndCommonHeaders(queryResponse, Status.INTERNAL_SERVER_ERROR.getStatusCode());
@@ -1964,7 +1964,7 @@ public class SqlResourceTest extends CalciteTestBase
""
);
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -1981,12 +1981,12 @@ public class SqlResourceTest extends CalciteTestBase
makeRegularUserReq()
)
);
- Assert.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel());
execLatch.countDown();
- Assert.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
+ Assertions.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus());
- Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
Response queryResponse = future.get();
assertStatusAndCommonHeaders(queryResponse, Status.INTERNAL_SERVER_ERROR.getStatusCode());
@@ -1994,7 +1994,7 @@ public class SqlResourceTest extends CalciteTestBase
ErrorResponse exception = deserializeResponse(queryResponse, ErrorResponse.class);
validateLegacyQueryExceptionErrorResponse(exception, "Query cancelled", null, "");
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -2011,15 +2011,15 @@ public class SqlResourceTest extends CalciteTestBase
makeRegularUserReq()
)
);
- Assert.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
Response cancelResponse = resource.cancelQuery("invalidQuery", makeRequestForCancel());
- Assert.assertEquals(Status.NOT_FOUND.getStatusCode(), cancelResponse.getStatus());
+ Assertions.assertEquals(Status.NOT_FOUND.getStatusCode(), cancelResponse.getStatus());
- Assert.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
+ Assertions.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
execLatch.countDown();
MockHttpServletResponse queryResponse = future.get();
- Assert.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
+ Assertions.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
}
@Test
@@ -2036,15 +2036,15 @@ public class SqlResourceTest extends CalciteTestBase
makeSuperUserReq()
)
);
- Assert.assertTrue(planLatch.await(3, TimeUnit.SECONDS));
+ Assertions.assertTrue(planLatch.await(3, TimeUnit.SECONDS));
Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel());
- Assert.assertEquals(Status.FORBIDDEN.getStatusCode(), cancelResponse.getStatus());
+ Assertions.assertEquals(Status.FORBIDDEN.getStatusCode(), cancelResponse.getStatus());
- Assert.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
+ Assertions.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty());
execLatch.countDown();
MockHttpServletResponse queryResponse = future.get();
- Assert.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
+ Assertions.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus());
}
@Test
@@ -2076,9 +2076,9 @@ public class SqlResourceTest extends CalciteTestBase
"2000'"
);
checkSqlRequestLog(false);
- Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
+ Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty());
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
@Test
@@ -2096,7 +2096,7 @@ public class SqlResourceTest extends CalciteTestBase
);
checkSqlRequestLog(false);
stubServiceEmitter.verifyEmitted("sqlQuery/time", 1);
- Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
+ Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE));
}
private void checkSqlRequestLog(boolean success)
@@ -2107,21 +2107,21 @@ public class SqlResourceTest extends CalciteTestBase
@SuppressWarnings("unchecked")
private void checkSqlRequestLog(boolean success, String user)
{
- Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
+ Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size());
final Map<String, Object> stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats();
final Map<String, Object> queryContext = (Map<String, Object>) testRequestLogger.getSqlQueryLogs()
.get(0)
.getSqlQueryContext();
- Assert.assertEquals(success, stats.get("success"));
- Assert.assertEquals(user, stats.get("identity"));
- Assert.assertTrue(stats.containsKey("sqlQuery/time"));
- Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
- Assert.assertTrue(queryContext.containsKey(QueryContexts.CTX_SQL_QUERY_ID));
+ Assertions.assertEquals(success, stats.get("success"));
+ Assertions.assertEquals(user, stats.get("identity"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/time"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs"));
+ Assertions.assertTrue(queryContext.containsKey(QueryContexts.CTX_SQL_QUERY_ID));
if (success) {
- Assert.assertTrue(stats.containsKey("sqlQuery/bytes"));
+ Assertions.assertTrue(stats.containsKey("sqlQuery/bytes"));
} else {
- Assert.assertTrue(stats.containsKey("exception"));
+ Assertions.assertTrue(stats.containsKey("exception"));
}
}
@@ -2188,7 +2188,7 @@ public class SqlResourceTest extends CalciteTestBase
final Object explicitQueryId = query.getContext().get("queryId");
final Object explicitSqlQueryId = query.getContext().get("sqlQueryId");
- Assert.assertNull(resource.doPost(query, req));
+ Assertions.assertNull(resource.doPost(query, req));
final Object actualQueryId = response.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER);
final Object actualSqlQueryId = response.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER);
@@ -2199,10 +2199,10 @@ public class SqlResourceTest extends CalciteTestBase
private void assertStatusAndCommonHeaders(MockHttpServletResponse queryResponse, int statusCode)
{
- Assert.assertEquals(statusCode, queryResponse.getStatus());
- Assert.assertEquals("application/json", queryResponse.getContentType());
- Assert.assertNotNull(queryResponse.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER));
- Assert.assertNotNull(queryResponse.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
+ Assertions.assertEquals(statusCode, queryResponse.getStatus());
+ Assertions.assertEquals("application/json", queryResponse.getContentType());
+ Assertions.assertNotNull(queryResponse.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER));
+ Assertions.assertNotNull(queryResponse.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
}
private <T> T deserializeResponse(MockHttpServletResponse resp, Class<T> clazz) throws IOException
@@ -2270,10 +2270,10 @@ public class SqlResourceTest extends CalciteTestBase
private void assertStatusAndCommonHeaders(Response queryResponse, int statusCode)
{
- Assert.assertEquals(statusCode, queryResponse.getStatus());
- Assert.assertEquals("application/json", getContentType(queryResponse));
- Assert.assertNotNull(getHeader(queryResponse, QueryResource.QUERY_ID_RESPONSE_HEADER));
- Assert.assertNotNull(getHeader(queryResponse, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
+ Assertions.assertEquals(statusCode, queryResponse.getStatus());
+ Assertions.assertEquals("application/json", getContentType(queryResponse));
+ Assertions.assertNotNull(getHeader(queryResponse, QueryResource.QUERY_ID_RESPONSE_HEADER));
+ Assertions.assertNotNull(getHeader(queryResponse, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER));
}
private void validateQueryIds(
@@ -2285,19 +2285,19 @@ public class SqlResourceTest extends CalciteTestBase
{
if (explicitQueryId == null) {
if (null != explicitSqlQueryId) {
- Assert.assertEquals(explicitSqlQueryId, actualQueryId);
- Assert.assertEquals(explicitSqlQueryId, actualSqlQueryId);
+ Assertions.assertEquals(explicitSqlQueryId, actualQueryId);
+ Assertions.assertEquals(explicitSqlQueryId, actualSqlQueryId);
} else {
- Assert.assertNotNull(actualQueryId);
- Assert.assertNotNull(actualSqlQueryId);
+ Assertions.assertNotNull(actualQueryId);
+ Assertions.assertNotNull(actualSqlQueryId);
}
} else {
if (explicitSqlQueryId == null) {
- Assert.assertEquals(explicitQueryId, actualQueryId);
- Assert.assertEquals(explicitQueryId, actualSqlQueryId);
+ Assertions.assertEquals(explicitQueryId, actualQueryId);
+ Assertions.assertEquals(explicitQueryId, actualSqlQueryId);
} else {
- Assert.assertEquals(explicitQueryId, actualQueryId);
- Assert.assertEquals(explicitSqlQueryId, actualSqlQueryId);
+ Assertions.assertEquals(explicitQueryId, actualQueryId);
+ Assertions.assertEquals(explicitSqlQueryId, actualSqlQueryId);
}
}
}
@@ -2496,17 +2496,17 @@ public class SqlResourceTest extends CalciteTestBase
String messageContainsString
)
{
- Assert.assertNotNull(errorResponse);
+ Assertions.assertNotNull(errorResponse);
DruidException exception = errorResponse.getUnderlyingException();
- Assert.assertEquals(errorCode, exception.getErrorCode());
- Assert.assertEquals(targetPersona, exception.getTargetPersona());
- Assert.assertEquals(category, exception.getCategory());
+ Assertions.assertEquals(errorCode, exception.getErrorCode());
+ Assertions.assertEquals(targetPersona, exception.getTargetPersona());
+ Assertions.assertEquals(category, exception.getCategory());
if (messageContainsString == null) {
- Assert.assertNull(exception.getMessage());
+ Assertions.assertNull(exception.getMessage());
} else {
- assertThat(exception.getMessage(), CoreMatchers.containsString(messageContainsString));
+ Assertions.assertTrue(exception.getMessage().contains(messageContainsString));
}
return exception;
@@ -2518,7 +2518,7 @@ public class SqlResourceTest extends CalciteTestBase
)
{
final DruidException exception = validateInvalidInputError(response, containsString);
- Assert.assertEquals("sql", exception.getContextValue("sourceType"));
+ Assertions.assertEquals("sql", exception.getContextValue("sourceType"));
return exception;
}
@@ -2550,8 +2550,8 @@ public class SqlResourceTest extends CalciteTestBase
messageContainsString
);
- Assert.assertEquals(legacyCode, exception.getContextValue("legacyErrorCode"));
- Assert.assertEquals(errorClass, exception.getContextValue("errorClass"));
+ Assertions.assertEquals(legacyCode, exception.getContextValue("legacyErrorCode"));
+ Assertions.assertEquals(errorClass, exception.getContextValue("errorClass"));
return exception;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org