This is an automated email from the ASF dual-hosted git repository.
FrankChen021 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 5dd74a82c38 test(sql): migrate SQL core and schema tests to JUnit 5
(#19939)
5dd74a82c38 is described below
commit 5dd74a82c386dbcf7fcb16ea41d6e190e66d8fee
Author: Frank Chen <[email protected]>
AuthorDate: Wed Aug 12 10:06:45 2026 +0800
test(sql): migrate SQL core and schema tests to JUnit 5 (#19939)
---
sql/pom.xml | 22 +-
.../druid/sql/calcite/CalciteArraysQueryTest.java | 6 +-
.../calcite/CalciteLookupFunctionQueryTest.java | 14 +-
.../druid/sql/calcite/CalciteWindowQueryTest.java | 24 +-
.../DecoupledPlanningCalciteJoinQueryTest.java | 2 +-
.../druid/sql/calcite/DrillWindowQueryTest.java | 15 +-
.../apache/druid/sql/calcite/NotYetSupported.java | 13 +-
...lVectorizedExpressionResultConsistencyTest.java | 49 ++--
.../BrokerSegmentMetadataCacheConcurrencyTest.java | 36 ++-
.../BrokerSegmentMetadataCacheConfigTest.java | 20 +-
.../schema/BrokerSegmentMetadataCacheTest.java | 312 ++++++++++----------
.../schema/BrokerSegmentMetadataCacheTestBase.java | 20 ++
.../calcite/schema/DruidSchemaNoDataInitTest.java | 4 +-
.../sql/calcite/schema/InformationSchemaTest.java | 41 +--
.../sql/calcite/schema/NamedDruidSchemaTest.java | 6 +-
.../sql/calcite/schema/NamedLookupSchemaTest.java | 6 +-
.../sql/calcite/schema/NamedSystemSchemaTest.java | 10 +-
.../PhysicalDataSourceMetadataFactoryTest.java | 24 +-
.../sql/calcite/schema/RootSchemaProviderTest.java | 12 +-
.../calcite/schema/SystemSchemaFiltersTest.java | 40 +--
.../druid/sql/calcite/schema/SystemSchemaTest.java | 323 +++++++++++----------
21 files changed, 505 insertions(+), 494 deletions(-)
diff --git a/sql/pom.xml b/sql/pom.xml
index a96f1a26e3c..a3a367150f5 100644
--- a/sql/pom.xml
+++ b/sql/pom.xml
@@ -214,6 +214,7 @@
</dependency>
<!-- Tests -->
+ <!-- Required while SegmentMetadataCacheTestBase in the server test-jar
still uses JUnit 4 TemporaryFolder. -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
@@ -244,32 +245,17 @@
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.junit.jupiter</groupId>
- <artifactId>junit-jupiter-migrationsupport</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-params</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.junit.vintage</groupId>
- <artifactId>junit-vintage-engine</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opentest4j</groupId>
<artifactId>opentest4j</artifactId>
<version>1.3.0</version>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>pl.pragmatists</groupId>
- <artifactId>JUnitParams</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
@@ -304,16 +290,12 @@
<type>test-jar</type>
<scope>test</scope>
</dependency>
+ <!-- DruidExceptionMatcher remains unchanged in this PR and is a Hamcrest
matcher. -->
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-core</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>nl.jqno.equalsverifier</groupId>
<artifactId>equalsverifier</artifactId>
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java
index 936d37c32c9..9e5ed1e05e4 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteArraysQueryTest.java
@@ -77,7 +77,7 @@ import org.apache.druid.sql.calcite.planner.PlannerContext;
import org.apache.druid.sql.calcite.util.CalciteTests;
import
org.apache.druid.sql.calcite.util.SqlTestFramework.StandardComponentSupplier;
import org.apache.druid.sql.http.SqlParameter;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
@@ -112,12 +112,12 @@ public class CalciteArraysQueryTest extends
BaseCalciteQueryTest
if (expected instanceof List && actual instanceof List) {
List expectedList = (List) expected;
List actualList = (List) actual;
- Assert.assertEquals(path + " arrays length mismatch",
expectedList.size(), actualList.size());
+ Assertions.assertEquals(expectedList.size(), actualList.size(), path + "
arrays length mismatch");
for (int i = 0; i < expectedList.size(); i++) {
assertDeepEquals(path + "[" + i + "]", expectedList.get(i),
actualList.get(i));
}
} else {
- Assert.assertEquals(path, expected, actual);
+ Assertions.assertEquals(expected, actual, path);
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteLookupFunctionQueryTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteLookupFunctionQueryTest.java
index e4055f84513..f17e05a0e50 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteLookupFunctionQueryTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteLookupFunctionQueryTest.java
@@ -53,19 +53,16 @@ import org.apache.druid.sql.calcite.planner.PlannerConfig;
import org.apache.druid.sql.calcite.planner.PlannerContext;
import org.apache.druid.sql.calcite.rule.ReverseLookupRule;
import org.apache.druid.sql.calcite.util.CalciteTests;
-import org.hamcrest.CoreMatchers;
-import org.junit.Assert;
-import org.junit.internal.matchers.ThrowableMessageMatcher;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.annotation.Nullable;
+
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
-import static org.hamcrest.MatcherAssert.assertThat;
-
public class CalciteLookupFunctionQueryTest extends BaseCalciteQueryTest
{
private static final Map<String, Object> QUERY_CONTEXT =
@@ -1333,7 +1330,7 @@ public class CalciteLookupFunctionQueryTest extends
BaseCalciteQueryTest
{
// Test to verify that "maxUnapplyCountForDruidReverseLookupRule" works
properly. This ensures that the *other*
// tests are correctly validating that we aren't doing too many reverse
lookups.
- final DruidException e = Assert.assertThrows(
+ final DruidException e = Assertions.assertThrows(
DruidException.class,
() -> testQuery(
buildFilterTestSql("LOOKUP(dim1, 'lookyloo') = 'xabc' OR
LOOKUP(dim2, 'lookyloo') = 'x6'"),
@@ -1343,10 +1340,7 @@ public class CalciteLookupFunctionQueryTest extends
BaseCalciteQueryTest
)
);
- assertThat(
- e,
- ThrowableMessageMatcher.hasMessage(CoreMatchers.startsWith("Too many
optimize calls[2]"))
- );
+ Assertions.assertTrue(e.getMessage().startsWith("Too many optimize
calls[2]"));
}
@Test
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteWindowQueryTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteWindowQueryTest.java
index 1b9f2fe7ad4..22d9f8d2463 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteWindowQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteWindowQueryTest.java
@@ -38,7 +38,7 @@ import
org.apache.druid.sql.calcite.CalciteWindowQueryTest.WindowQueryTestInputC
import org.apache.druid.sql.calcite.QueryTestRunner.QueryResults;
import org.apache.druid.sql.calcite.QueryVerification.QueryResultsVerifier;
import org.apache.druid.sql.calcite.planner.PlannerContext;
-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;
@@ -52,9 +52,9 @@ import java.util.Locale;
import java.util.Map;
import java.util.Objects;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
/**
@@ -126,7 +126,7 @@ public class CalciteWindowQueryTest extends
BaseCalciteQueryTest
if (results.exception != null) {
throw new RE(results.exception, "Failed to execute because of
exception.");
}
- Assert.assertEquals(1, results.recordedQueries.size());
+ Assertions.assertEquals(1, results.recordedQueries.size());
maybeDumpActualResults(results.results);
if (input.expectedOperators != null) {
@@ -138,7 +138,7 @@ public class CalciteWindowQueryTest extends
BaseCalciteQueryTest
ColumnType[] types = new ColumnType[outputSignature.size()];
for (int i = 0; i < outputSignature.size(); ++i) {
types[i] = outputSignature.getColumnType(i).get();
- Assert.assertEquals(types[i],
results.signature.getColumnType(i).get());
+ Assertions.assertEquals(types[i],
results.signature.getColumnType(i).get());
}
for (Object[] result : input.expectedResults) {
@@ -178,13 +178,15 @@ public class CalciteWindowQueryTest extends
BaseCalciteQueryTest
final OperatorFactory expectedOperator = expectedOperators.get(i);
final OperatorFactory actualOperator = currentOperators.get(i);
if (!expectedOperator.validateEquivalent(actualOperator)) {
- assertEquals("Operator Mismatch, index[" + i + "]",
+ assertEquals(
queryJackson.writeValueAsString(expectedOperator),
- queryJackson.writeValueAsString(actualOperator));
+ queryJackson.writeValueAsString(actualOperator),
+ "Operator Mismatch, index[" + i + "]"
+ );
fail("validateEquivalent failed; but textual comparision of
operators didn't reported the mismatch!");
}
}
- assertEquals("Operator count mismatch!", expectedOperators.size(),
currentOperators.size());
+ assertEquals(expectedOperators.size(), currentOperators.size(),
"Operator count mismatch!");
}
private void maybeDumpActualResults(List<Object[]> results) throws
Exception
@@ -284,7 +286,7 @@ public class CalciteWindowQueryTest extends
BaseCalciteQueryTest
@Test
public void testFailure_partitionByMVD()
{
- final DruidException e = Assert.assertThrows(
+ final DruidException e = Assertions.assertThrows(
DruidException.class,
() -> testBuilder()
.sql("select cityName, countryName,
array_to_mv(array[1,length(cityName)]),\n"
@@ -302,7 +304,7 @@ public class CalciteWindowQueryTest extends
BaseCalciteQueryTest
e.getMessage()
);
- final DruidException e1 = Assert.assertThrows(
+ final DruidException e1 = Assertions.assertThrows(
DruidException.class,
() -> testBuilder()
.sql("select cityName, countryName,
array_to_mv(array[1,length(cityName)]),\n"
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteJoinQueryTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteJoinQueryTest.java
index f0e409c1645..3f86e6ffc51 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteJoinQueryTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/DecoupledPlanningCalciteJoinQueryTest.java
@@ -26,7 +26,7 @@ import org.junit.jupiter.params.provider.MethodSource;
import java.util.Map;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
public class DecoupledPlanningCalciteJoinQueryTest extends CalciteJoinQueryTest
{
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/DrillWindowQueryTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/DrillWindowQueryTest.java
index e502266d1d8..d6ff88fe4e9 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/DrillWindowQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/DrillWindowQueryTest.java
@@ -44,7 +44,7 @@ import
org.apache.druid.sql.calcite.util.SqlTestFramework.StandardComponentSuppl
import org.apache.druid.sql.calcite.util.TestDataBuilder;
import org.joda.time.DateTime;
import org.joda.time.LocalTime;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
@@ -52,6 +52,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
+
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
@@ -73,9 +74,9 @@ import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
/**
@@ -139,7 +140,7 @@ public class DrillWindowQueryTest extends
BaseCalciteQueryTest
string,
string.replace('/', '_'));
}
- assertEquals("Found some non-declared testcases; please add the new
testcases printed to the console!", 0, allCases.size());
+ assertEquals(0, allCases.size(), "Found some non-declared testcases;
please add the new testcases printed to the console!");
}
@Retention(RetentionPolicy.RUNTIME)
@@ -253,7 +254,7 @@ public class DrillWindowQueryTest extends
BaseCalciteQueryTest
public void verifyRowSignature(RowSignature rowSignature)
{
if (expectedResultRowSignature != null) {
- Assert.assertEquals(expectedResultRowSignature, rowSignature);
+ Assertions.assertEquals(expectedResultRowSignature, rowSignature);
}
currentRowSignature = rowSignature;
}
@@ -264,7 +265,7 @@ public class DrillWindowQueryTest extends
BaseCalciteQueryTest
List<Object[]> results = queryResults.results;
List<Object[]> expectedResults = parseResults(currentRowSignature,
expectedResultsText);
try {
- Assert.assertEquals(StringUtils.format("result count: %s", sql),
expectedResultsText.size(), results.size());
+ Assertions.assertEquals(expectedResultsText.size(), results.size(),
StringUtils.format("result count: %s", sql));
if (!isOrdered(queryResults)) {
// in case the resultset is not ordered; order via the same
comparator before comparison
results.sort(new ArrayRowCmp());
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java
b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java
index 4d5d21ec888..e3a544c5f4e 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java
@@ -26,6 +26,7 @@ import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.InvocationInterceptor;
import org.junit.jupiter.api.extension.ReflectiveInvocationContext;
import org.opentest4j.IncompleteExecutionException;
+import org.opentest4j.TestAbortedException;
import javax.annotation.Nullable;
@@ -37,7 +38,7 @@ import java.lang.reflect.Method;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import static org.junit.Assert.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Can be used to mark tests which are not-yet supported for some reason.
@@ -187,21 +188,21 @@ public @interface NotYetSupported
}
// If the base test case is supposed to be ignored already, just skip
// the further evaluation
- if (e instanceof AssumptionViolatedException) {
- throw (AssumptionViolatedException) e;
+ if (e instanceof AssumptionViolatedException || e instanceof
TestAbortedException) {
+ throw e;
}
if (e instanceof IncompleteExecutionException) {
throw (IncompleteExecutionException) e;
}
Throwable finalE = e;
assertThrows(
- "Expected that this testcase will fail - it might got fixed; or
failure have changed?",
ignoreMode.throwableClass,
() -> {
if (finalE != null) {
throw finalE;
}
- }
+ },
+ "Expected that this testcase will fail - it might got fixed; or
failure have changed?"
);
String trace = Throwables.getStackTraceAsString(e);
@@ -210,7 +211,7 @@ public @interface NotYetSupported
if (!m.find()) {
throw new AssertionError("Exception stacktrace doesn't match
regex: " + ignoreMode.regex, e);
}
- throw new AssumptionViolatedException("Test is not-yet supported;
ignored with:" + annotation);
+ throw new TestAbortedException("Test is not-yet supported; ignored
with:" + annotation);
}
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionResultConsistencyTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionResultConsistencyTest.java
index 75157793dd0..4ebc253c7c5 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionResultConsistencyTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/SqlVectorizedExpressionResultConsistencyTest.java
@@ -54,20 +54,22 @@ import org.apache.druid.sql.hook.DruidHookDispatcher;
import org.apache.druid.testing.InitializedNullHandlingTest;
import org.apache.druid.timeline.DataSegment;
import org.apache.druid.timeline.partition.LinearShardSpec;
-import org.junit.AfterClass;
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+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 org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
import javax.annotation.Nullable;
+
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
-@RunWith(Parameterized.class)
+@ParameterizedClass(name = "query = {0}")
+@MethodSource("constructorFeeder")
public class SqlVectorizedExpressionResultConsistencyTest extends
InitializedNullHandlingTest
{
private static final Logger log = new
Logger(SqlVectorizedExpressionResultConsistencyTest.class);
@@ -111,7 +113,7 @@ public class SqlVectorizedExpressionResultConsistencyTest
extends InitializedNul
@Nullable
private static PlannerFactory PLANNER_FACTORY;
- @BeforeClass
+ @BeforeAll
public static void setupClass()
{
CLOSER = Closer.create();
@@ -160,19 +162,18 @@ public class SqlVectorizedExpressionResultConsistencyTest
extends InitializedNul
);
}
- @AfterClass
+ @AfterAll
public static void teardownClass() throws IOException
{
CLOSER.close();
}
- @Parameterized.Parameters(name = "query = {0}")
public static Iterable<?> constructorFeeder()
{
return QUERIES.stream().map(x -> new
Object[]{x}).collect(Collectors.toList());
}
- private String query;
+ private final String query;
public SqlVectorizedExpressionResultConsistencyTest(String query)
{
@@ -213,32 +214,32 @@ public class SqlVectorizedExpressionResultConsistencyTest
extends InitializedNul
Object[] nonVectorizedGet = nonVectorizedYielder.get();
try {
- Assert.assertEquals(vectorGet.length, nonVectorizedGet.length);
+ Assertions.assertEquals(vectorGet.length, nonVectorizedGet.length);
for (int i = 0; i < vectorGet.length; i++) {
Object nonVectorObject = nonVectorizedGet[i];
Object vectorObject = vectorGet[i];
if (vectorObject instanceof Float || vectorObject instanceof
Double) {
- Assert.assertEquals(
+ Assertions.assertEquals(
+ ((Number) nonVectorObject).doubleValue(),
+ ((Number) vectorObject).doubleValue(),
+ 0.01,
StringUtils.format(
"Double results differed at row %s (%s : %s)",
row,
nonVectorObject,
vectorObject
- ),
- ((Number) nonVectorObject).doubleValue(),
- ((Number) vectorObject).doubleValue(),
- 0.01
+ )
);
} else {
- Assert.assertEquals(
+ Assertions.assertEquals(
+ nonVectorObject,
+ vectorObject,
StringUtils.format(
"Results differed at row %s (%s : %s)",
row,
nonVectorObject,
vectorObject
- ),
- nonVectorObject,
- vectorObject
+ )
);
}
}
@@ -251,9 +252,9 @@ public class SqlVectorizedExpressionResultConsistencyTest
extends InitializedNul
nonVectorizedYielder = nonVectorizedYielder.next(nonVectorizedGet);
row++;
}
- Assert.assertEquals("Expected no mismatched results", 0, misMatch);
- Assert.assertTrue(vectorizedYielder.isDone());
- Assert.assertTrue(nonVectorizedYielder.isDone());
+ Assertions.assertEquals(0, misMatch, "Expected no mismatched results");
+ Assertions.assertTrue(vectorizedYielder.isDone());
+ Assertions.assertTrue(nonVectorizedYielder.isDone());
}
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConcurrencyTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConcurrencyTest.java
index e31bcbbdfae..78c936552cd 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConcurrencyTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConcurrencyTest.java
@@ -66,12 +66,14 @@ import org.apache.druid.timeline.SegmentId;
import org.apache.druid.timeline.partition.NumberedShardSpec;
import org.easymock.Capture;
import org.easymock.EasyMock;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+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.Timeout;
import javax.annotation.Nullable;
+
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
@@ -99,12 +101,12 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
private AbstractSegmentMetadataCache schema;
private ExecutorService exec;
- @Before
+ @BeforeEach
@Override
public void setUp() throws Exception
{
super.setUp();
- tmpDir = temporaryFolder.newFolder();
+ tmpDir = newTempFolder();
walker = SpecificSegmentsQuerySegmentWalker.createWalker(conglomerate);
inventoryView = new TestServerInventoryView();
serverView = newBrokerServerView(inventoryView);
@@ -113,12 +115,12 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
exec = Execs.multiThreaded(4, "DruidSchemaConcurrencyTest-%d");
}
- @After
+ @AfterEach
@Override
public void tearDown() throws Exception
{
- super.tearDown();
exec.shutdownNow();
+ super.tearDown();
}
/**
@@ -133,7 +135,8 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
* {@link BrokerServerView#getTimeline} is continuously called to mimic user
query
* processing. All these calls must return without heavy contention.
*/
- @Test(timeout = 30000L)
+ @Test
+ @Timeout(value = 30, unit = TimeUnit.SECONDS)
public void
testSegmentMetadataRefreshAndInventoryViewAddSegmentAndBrokerServerViewGetTimeline()
throws InterruptedException, ExecutionException, TimeoutException
{
@@ -206,7 +209,7 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
);
addSegmentsToCluster(0, numServers, numExistingSegments);
// Wait for all segments to be loaded in BrokerServerView
- Assert.assertTrue(segmentLoadLatch.await(5, TimeUnit.SECONDS));
+ Assertions.assertTrue(segmentLoadLatch.await(5, TimeUnit.SECONDS));
// Trigger refresh of DruidSchema. This will internally run the heavy work
// mimicked by the overridden buildDruidTable
@@ -224,14 +227,14 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
// for the first 30 segments, we will still have replicas.
// for the other 20 segments, they will be completely removed from the
cluster.
removeSegmentsFromCluster(numServers, 50);
- Assert.assertFalse(refreshFuture.isDone());
+ Assertions.assertFalse(refreshFuture.isDone());
for (int i = 0; i < 1000; i++) {
boolean hasTimeline = exec.submit(
() -> serverView.getTimeline((new TableDataSource(DATASOURCE)))
.isPresent()
).get(100, TimeUnit.MILLISECONDS);
- Assert.assertTrue(hasTimeline);
+ Assertions.assertTrue(hasTimeline);
// We want to call getTimeline while BrokerServerView is being updated.
Sleep might help with timing.
Thread.sleep(2);
}
@@ -250,7 +253,8 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
* called to mimic reading the segments table of SystemSchema. All these
calls
* must return without heavy contention.
*/
- @Test(timeout = 30000L)
+ @Test
+ @Timeout(value = 30, unit = TimeUnit.SECONDS)
public void testSegmentMetadataRefreshAndDruidSchemaGetSegmentMetadata()
throws InterruptedException, ExecutionException, TimeoutException
{
@@ -326,7 +330,7 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
);
addSegmentsToCluster(0, numServers, numExistingSegments);
// Wait for all segments to be loaded in BrokerServerView
- Assert.assertTrue(segmentLoadLatch.await(5, TimeUnit.SECONDS));
+ Assertions.assertTrue(segmentLoadLatch.await(5, TimeUnit.SECONDS));
// Trigger refresh of SegmentMetadataCache. This will internally run the
heavy work mimicked
// by the overridden buildDruidTable
@@ -337,13 +341,13 @@ public class BrokerSegmentMetadataCacheConcurrencyTest
extends BrokerSegmentMeta
);
return null;
});
- Assert.assertFalse(refreshFuture.isDone());
+ Assertions.assertFalse(refreshFuture.isDone());
for (int i = 0; i < 1000; i++) {
Map<SegmentId, AvailableSegmentMetadata> segmentsMetadata = exec.submit(
() -> schema.getSegmentMetadataSnapshot()
).get(100, TimeUnit.MILLISECONDS);
- Assert.assertFalse(segmentsMetadata.isEmpty());
+ Assertions.assertFalse(segmentsMetadata.isEmpty());
// We want to call getTimeline while refreshing. Sleep might help with
timing.
Thread.sleep(2);
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConfigTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConfigTest.java
index 811f99adf06..1d9490fccb2 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConfigTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheConfigTest.java
@@ -27,8 +27,8 @@ import org.apache.druid.guice.JsonConfigurator;
import org.apache.druid.segment.metadata.AbstractSegmentMetadataCache;
import org.apache.druid.sql.calcite.planner.CalcitePlannerModule;
import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
import java.util.Properties;
@@ -49,10 +49,10 @@ public class BrokerSegmentMetadataCacheConfigTest
final Properties properties = new Properties();
provider.inject(properties, injector.getInstance(JsonConfigurator.class));
final BrokerSegmentMetadataCacheConfig config = provider.get();
- Assert.assertTrue(config.isAwaitInitializationOnStart());
- Assert.assertTrue(config.isMetadataSegmentCacheEnable());
- Assert.assertEquals(Period.minutes(1), config.getMetadataRefreshPeriod());
- Assert.assertEquals(new
AbstractSegmentMetadataCache.LeastRestrictiveTypeMergePolicy(),
config.getMetadataColumnTypeMergePolicy());
+ Assertions.assertTrue(config.isAwaitInitializationOnStart());
+ Assertions.assertTrue(config.isMetadataSegmentCacheEnable());
+ Assertions.assertEquals(Period.minutes(1),
config.getMetadataRefreshPeriod());
+ Assertions.assertEquals(new
AbstractSegmentMetadataCache.LeastRestrictiveTypeMergePolicy(),
config.getMetadataColumnTypeMergePolicy());
}
@Test
@@ -73,10 +73,10 @@ public class BrokerSegmentMetadataCacheConfigTest
properties.setProperty(CONFIG_BASE + ".metadataSegmentCacheEnable",
"false");
provider.inject(properties, injector.getInstance(JsonConfigurator.class));
final BrokerSegmentMetadataCacheConfig config = provider.get();
- Assert.assertFalse(config.isAwaitInitializationOnStart());
- Assert.assertFalse(config.isMetadataSegmentCacheEnable());
- Assert.assertEquals(Period.minutes(2), config.getMetadataRefreshPeriod());
- Assert.assertEquals(
+ Assertions.assertFalse(config.isAwaitInitializationOnStart());
+ Assertions.assertFalse(config.isMetadataSegmentCacheEnable());
+ Assertions.assertEquals(Period.minutes(2),
config.getMetadataRefreshPeriod());
+ Assertions.assertEquals(
new AbstractSegmentMetadataCache.FirstTypeMergePolicy(),
config.getMetadataColumnTypeMergePolicy()
);
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTest.java
index c3a77888d4e..55abaf7b4a3 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTest.java
@@ -84,10 +84,10 @@ import
org.apache.druid.timeline.partition.NumberedShardSpec;
import org.apache.druid.timeline.partition.TombstoneShardSpec;
import org.easymock.EasyMock;
import org.joda.time.Period;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+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.mockito.ArgumentCaptor;
import org.mockito.Mockito;
@@ -121,22 +121,22 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
private CountDownLatch markDataSourceLatch = new CountDownLatch(1);
private CountDownLatch refreshLatch = new CountDownLatch(1);
- @Before
+ @BeforeEach
@Override
public void setUp() throws Exception
{
super.setUp();
}
- @After
+ @AfterEach
@Override
public void tearDown() throws Exception
{
- super.tearDown();
if (runningSchema != null) {
runningSchema.stop();
}
walker.close();
+ super.tearDown();
}
public BrokerSegmentMetadataCache buildSchemaMarkAndTableLatch() throws
InterruptedException
@@ -269,17 +269,17 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
schema.start();
schema.awaitInitialization();
final Set<String> tableNames = schema.getDatasourceNames();
- Assert.assertEquals(ImmutableSet.of(
+ Assertions.assertEquals(ImmutableSet.of(
CalciteTests.DATASOURCE1,
CalciteTests.DATASOURCE2,
CalciteTests.SOME_DATASOURCE,
"foo3"
), tableNames);
- Assert.assertEquals(dataSource1RowSignature,
schema.getDatasource(DATASOURCE1).getRowSignature());
- Assert.assertEquals(dataSource2RowSignature,
schema.getDatasource(DATASOURCE2).getRowSignature());
- Assert.assertEquals(someDataSourceRowSignature,
schema.getDatasource(SOME_DATASOURCE).getRowSignature());
- Assert.assertEquals(foo3RowSignature,
schema.getDatasource("foo3").getRowSignature());
+ Assertions.assertEquals(dataSource1RowSignature,
schema.getDatasource(DATASOURCE1).getRowSignature());
+ Assertions.assertEquals(dataSource2RowSignature,
schema.getDatasource(DATASOURCE2).getRowSignature());
+ Assertions.assertEquals(someDataSourceRowSignature,
schema.getDatasource(SOME_DATASOURCE).getRowSignature());
+ Assertions.assertEquals(foo3RowSignature,
schema.getDatasource("foo3").getRowSignature());
}
/**
@@ -382,7 +382,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
schema.start();
schema.awaitInitialization();
- Assert.assertEquals(datsources, argumentCaptor.getValue());
+ Assertions.assertEquals(datsources, argumentCaptor.getValue());
refreshLatch = new CountDownLatch(1);
serverView.addSegment(newSegment("xyz", 0), ServerType.HISTORICAL);
@@ -390,7 +390,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS);
// verify that previously refreshed are included in the last coordinator
poll
- Assert.assertEquals(datsources, argumentCaptor.getValue());
+ Assertions.assertEquals(datsources, argumentCaptor.getValue());
}
@Test
@@ -435,7 +435,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
emitter.verifyValue(Metric.SCHEMA_ROW_SIGNATURE_COLUMN_COUNT,
Map.of(DruidMetrics.DATASOURCE, "foo2"), 3L);
emitter.verifyValue(Metric.SCHEMA_ROW_SIGNATURE_COLUMN_COUNT,
Map.of(DruidMetrics.DATASOURCE, "some_datasource"), 9L);
- Assert.assertEquals(0, refreshLatch.getCount());
+ Assertions.assertEquals(0, refreshLatch.getCount());
}
@Test
@@ -475,14 +475,14 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS);
- Assert.assertEquals(2, refreshLatch.getCount());
+ Assertions.assertEquals(2, refreshLatch.getCount());
}
@Test
public void testGetTableMap() throws InterruptedException
{
BrokerSegmentMetadataCache schema = buildSchemaMarkAndTableLatch();
- Assert.assertEquals(ImmutableSet.of(
+ Assertions.assertEquals(ImmutableSet.of(
CalciteTests.DATASOURCE1,
CalciteTests.DATASOURCE2,
CalciteTests.SOME_DATASOURCE
@@ -498,25 +498,25 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
final RelDataType rowType = fooTable.getRowType(new JavaTypeFactoryImpl());
final List<RelDataTypeField> fields = rowType.getFieldList();
- Assert.assertEquals(6, fields.size());
+ Assertions.assertEquals(6, fields.size());
- Assert.assertEquals("__time", fields.get(0).getName());
- Assert.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
+ Assertions.assertEquals("__time", fields.get(0).getName());
+ Assertions.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
- Assert.assertEquals("dim2", fields.get(1).getName());
- Assert.assertEquals(SqlTypeName.VARCHAR,
fields.get(1).getType().getSqlTypeName());
+ Assertions.assertEquals("dim2", fields.get(1).getName());
+ Assertions.assertEquals(SqlTypeName.VARCHAR,
fields.get(1).getType().getSqlTypeName());
- Assert.assertEquals("m1", fields.get(2).getName());
- Assert.assertEquals(SqlTypeName.DOUBLE,
fields.get(2).getType().getSqlTypeName());
+ Assertions.assertEquals("m1", fields.get(2).getName());
+ Assertions.assertEquals(SqlTypeName.DOUBLE,
fields.get(2).getType().getSqlTypeName());
- Assert.assertEquals("dim1", fields.get(3).getName());
- Assert.assertEquals(SqlTypeName.VARCHAR,
fields.get(3).getType().getSqlTypeName());
+ Assertions.assertEquals("dim1", fields.get(3).getName());
+ Assertions.assertEquals(SqlTypeName.VARCHAR,
fields.get(3).getType().getSqlTypeName());
- Assert.assertEquals("cnt", fields.get(4).getName());
- Assert.assertEquals(SqlTypeName.BIGINT,
fields.get(4).getType().getSqlTypeName());
+ Assertions.assertEquals("cnt", fields.get(4).getName());
+ Assertions.assertEquals(SqlTypeName.BIGINT,
fields.get(4).getType().getSqlTypeName());
- Assert.assertEquals("unique_dim1", fields.get(5).getName());
- Assert.assertEquals(SqlTypeName.OTHER,
fields.get(5).getType().getSqlTypeName());
+ Assertions.assertEquals("unique_dim1", fields.get(5).getName());
+ Assertions.assertEquals(SqlTypeName.OTHER,
fields.get(5).getType().getSqlTypeName());
}
@Test
@@ -528,16 +528,16 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
final RelDataType rowType = fooTable.getRowType(new JavaTypeFactoryImpl());
final List<RelDataTypeField> fields = rowType.getFieldList();
- Assert.assertEquals(3, fields.size());
+ Assertions.assertEquals(3, fields.size());
- Assert.assertEquals("__time", fields.get(0).getName());
- Assert.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
+ Assertions.assertEquals("__time", fields.get(0).getName());
+ Assertions.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
- Assert.assertEquals("dim2", fields.get(1).getName());
- Assert.assertEquals(SqlTypeName.VARCHAR,
fields.get(1).getType().getSqlTypeName());
+ Assertions.assertEquals("dim2", fields.get(1).getName());
+ Assertions.assertEquals(SqlTypeName.VARCHAR,
fields.get(1).getType().getSqlTypeName());
- Assert.assertEquals("m1", fields.get(2).getName());
- Assert.assertEquals(SqlTypeName.BIGINT,
fields.get(2).getType().getSqlTypeName());
+ Assertions.assertEquals("m1", fields.get(2).getName());
+ Assertions.assertEquals(SqlTypeName.BIGINT,
fields.get(2).getType().getSqlTypeName());
}
@Test
@@ -561,36 +561,36 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
final RelDataType rowType = table.getRowType(new JavaTypeFactoryImpl());
final List<RelDataTypeField> fields = rowType.getFieldList();
- Assert.assertEquals(9, fields.size());
+ Assertions.assertEquals(9, fields.size());
- Assert.assertEquals("__time", fields.get(0).getName());
- Assert.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
+ Assertions.assertEquals("__time", fields.get(0).getName());
+ Assertions.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
- Assert.assertEquals("numbery", fields.get(1).getName());
- Assert.assertEquals(SqlTypeName.BIGINT,
fields.get(1).getType().getSqlTypeName());
+ Assertions.assertEquals("numbery", fields.get(1).getName());
+ Assertions.assertEquals(SqlTypeName.BIGINT,
fields.get(1).getType().getSqlTypeName());
- Assert.assertEquals("numberyArrays", fields.get(2).getName());
- Assert.assertEquals(SqlTypeName.ARRAY,
fields.get(2).getType().getSqlTypeName());
- Assert.assertEquals(SqlTypeName.DOUBLE,
fields.get(2).getType().getComponentType().getSqlTypeName());
+ Assertions.assertEquals("numberyArrays", fields.get(2).getName());
+ Assertions.assertEquals(SqlTypeName.ARRAY,
fields.get(2).getType().getSqlTypeName());
+ Assertions.assertEquals(SqlTypeName.DOUBLE,
fields.get(2).getType().getComponentType().getSqlTypeName());
- Assert.assertEquals("stringy", fields.get(3).getName());
- Assert.assertEquals(SqlTypeName.VARCHAR,
fields.get(3).getType().getSqlTypeName());
+ Assertions.assertEquals("stringy", fields.get(3).getName());
+ Assertions.assertEquals(SqlTypeName.VARCHAR,
fields.get(3).getType().getSqlTypeName());
- Assert.assertEquals("array", fields.get(4).getName());
- Assert.assertEquals(SqlTypeName.ARRAY,
fields.get(4).getType().getSqlTypeName());
- Assert.assertEquals(SqlTypeName.BIGINT,
fields.get(4).getType().getComponentType().getSqlTypeName());
+ Assertions.assertEquals("array", fields.get(4).getName());
+ Assertions.assertEquals(SqlTypeName.ARRAY,
fields.get(4).getType().getSqlTypeName());
+ Assertions.assertEquals(SqlTypeName.BIGINT,
fields.get(4).getType().getComponentType().getSqlTypeName());
- Assert.assertEquals("nested", fields.get(5).getName());
- Assert.assertEquals(SqlTypeName.OTHER,
fields.get(5).getType().getSqlTypeName());
+ Assertions.assertEquals("nested", fields.get(5).getName());
+ Assertions.assertEquals(SqlTypeName.OTHER,
fields.get(5).getType().getSqlTypeName());
- Assert.assertEquals("cnt", fields.get(6).getName());
- Assert.assertEquals(SqlTypeName.BIGINT,
fields.get(6).getType().getSqlTypeName());
+ Assertions.assertEquals("cnt", fields.get(6).getName());
+ Assertions.assertEquals(SqlTypeName.BIGINT,
fields.get(6).getType().getSqlTypeName());
- Assert.assertEquals("m1", fields.get(7).getName());
- Assert.assertEquals(SqlTypeName.DOUBLE,
fields.get(7).getType().getSqlTypeName());
+ Assertions.assertEquals("m1", fields.get(7).getName());
+ Assertions.assertEquals(SqlTypeName.DOUBLE,
fields.get(7).getType().getSqlTypeName());
- Assert.assertEquals("unique_dim1", fields.get(8).getName());
- Assert.assertEquals(SqlTypeName.OTHER,
fields.get(8).getType().getSqlTypeName());
+ Assertions.assertEquals("unique_dim1", fields.get(8).getName());
+ Assertions.assertEquals(SqlTypeName.OTHER,
fields.get(8).getType().getSqlTypeName());
}
@Test
@@ -604,37 +604,37 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
final RelDataType rowType = table.getRowType(new JavaTypeFactoryImpl());
final List<RelDataTypeField> fields = rowType.getFieldList();
- Assert.assertEquals(9, fields.size());
+ Assertions.assertEquals(9, fields.size());
- Assert.assertEquals("__time", fields.get(0).getName());
- Assert.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
+ Assertions.assertEquals("__time", fields.get(0).getName());
+ Assertions.assertEquals(SqlTypeName.TIMESTAMP,
fields.get(0).getType().getSqlTypeName());
- Assert.assertEquals("numbery", fields.get(1).getName());
- Assert.assertEquals(SqlTypeName.DOUBLE,
fields.get(1).getType().getSqlTypeName());
+ Assertions.assertEquals("numbery", fields.get(1).getName());
+ Assertions.assertEquals(SqlTypeName.DOUBLE,
fields.get(1).getType().getSqlTypeName());
- Assert.assertEquals("numberyArrays", fields.get(2).getName());
- Assert.assertEquals(SqlTypeName.ARRAY,
fields.get(2).getType().getSqlTypeName());
- Assert.assertEquals(SqlTypeName.DOUBLE,
fields.get(2).getType().getComponentType().getSqlTypeName());
+ Assertions.assertEquals("numberyArrays", fields.get(2).getName());
+ Assertions.assertEquals(SqlTypeName.ARRAY,
fields.get(2).getType().getSqlTypeName());
+ Assertions.assertEquals(SqlTypeName.DOUBLE,
fields.get(2).getType().getComponentType().getSqlTypeName());
- Assert.assertEquals("stringy", fields.get(3).getName());
- Assert.assertEquals(SqlTypeName.ARRAY,
fields.get(3).getType().getSqlTypeName());
- Assert.assertEquals(SqlTypeName.VARCHAR,
fields.get(3).getType().getComponentType().getSqlTypeName());
+ Assertions.assertEquals("stringy", fields.get(3).getName());
+ Assertions.assertEquals(SqlTypeName.ARRAY,
fields.get(3).getType().getSqlTypeName());
+ Assertions.assertEquals(SqlTypeName.VARCHAR,
fields.get(3).getType().getComponentType().getSqlTypeName());
- Assert.assertEquals("array", fields.get(4).getName());
- Assert.assertEquals(SqlTypeName.ARRAY,
fields.get(4).getType().getSqlTypeName());
- Assert.assertEquals(SqlTypeName.DOUBLE,
fields.get(4).getType().getComponentType().getSqlTypeName());
+ Assertions.assertEquals("array", fields.get(4).getName());
+ Assertions.assertEquals(SqlTypeName.ARRAY,
fields.get(4).getType().getSqlTypeName());
+ Assertions.assertEquals(SqlTypeName.DOUBLE,
fields.get(4).getType().getComponentType().getSqlTypeName());
- Assert.assertEquals("nested", fields.get(5).getName());
- Assert.assertEquals(SqlTypeName.OTHER,
fields.get(5).getType().getSqlTypeName());
+ Assertions.assertEquals("nested", fields.get(5).getName());
+ Assertions.assertEquals(SqlTypeName.OTHER,
fields.get(5).getType().getSqlTypeName());
- Assert.assertEquals("cnt", fields.get(6).getName());
- Assert.assertEquals(SqlTypeName.BIGINT,
fields.get(6).getType().getSqlTypeName());
+ Assertions.assertEquals("cnt", fields.get(6).getName());
+ Assertions.assertEquals(SqlTypeName.BIGINT,
fields.get(6).getType().getSqlTypeName());
- Assert.assertEquals("m1", fields.get(7).getName());
- Assert.assertEquals(SqlTypeName.DOUBLE,
fields.get(7).getType().getSqlTypeName());
+ Assertions.assertEquals("m1", fields.get(7).getName());
+ Assertions.assertEquals(SqlTypeName.DOUBLE,
fields.get(7).getType().getSqlTypeName());
- Assert.assertEquals("unique_dim1", fields.get(8).getName());
- Assert.assertEquals(SqlTypeName.OTHER,
fields.get(8).getType().getSqlTypeName());
+ Assertions.assertEquals("unique_dim1", fields.get(8).getName());
+ Assertions.assertEquals(SqlTypeName.OTHER,
fields.get(8).getType().getSqlTypeName());
}
/**
@@ -654,13 +654,13 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.stream()
.map(AvailableSegmentMetadata::getSegment)
.collect(Collectors.toList());
- Assert.assertEquals(6, segments.size());
+ Assertions.assertEquals(6, segments.size());
// find the only segment with datasource "foo2"
final DataSegment existingSegment = segments.stream()
.filter(segment ->
segment.getDataSource().equals("foo2"))
.findFirst()
.orElse(null);
- Assert.assertNotNull(existingSegment);
+ Assertions.assertNotNull(existingSegment);
final AvailableSegmentMetadata existingMetadata =
segmentsMetadata.get(existingSegment.getId());
// update AvailableSegmentMetadata of existingSegment with numRows=5
AvailableSegmentMetadata updatedMetadata =
AvailableSegmentMetadata.from(existingMetadata).withNumRows(5).build();
@@ -676,9 +676,9 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
)
.findAny()
.orElse(null);
- Assert.assertNotNull(pair);
+ Assertions.assertNotNull(pair);
final ImmutableDruidServer server = pair.lhs;
- Assert.assertNotNull(server);
+ Assertions.assertNotNull(server);
final DruidServerMetadata druidServerMetadata = server.getMetadata();
// invoke SegmentMetadataCache#addSegment on existingSegment
schema.addSegment(druidServerMetadata, existingSegment);
@@ -689,10 +689,10 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.findFirst()
.orElse(null);
final AvailableSegmentMetadata currentMetadata =
segmentsMetadata.get(currentSegment.getId());
- Assert.assertEquals(updatedMetadata.getSegment().getId(),
currentMetadata.getSegment().getId());
- Assert.assertEquals(updatedMetadata.getNumRows(),
currentMetadata.getNumRows());
+ Assertions.assertEquals(updatedMetadata.getSegment().getId(),
currentMetadata.getSegment().getId());
+ Assertions.assertEquals(updatedMetadata.getNumRows(),
currentMetadata.getNumRows());
// numreplicas do not change here since we addSegment with the same server
which was serving existingSegment before
- Assert.assertEquals(updatedMetadata.getNumReplicas(),
currentMetadata.getNumReplicas());
+ Assertions.assertEquals(updatedMetadata.getNumReplicas(),
currentMetadata.getNumReplicas());
}
@Test
@@ -704,20 +704,20 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.stream()
.map(AvailableSegmentMetadata::getSegment)
.collect(Collectors.toList());
- Assert.assertEquals(6, segments.size());
+ Assertions.assertEquals(6, segments.size());
// segments contains two segments with datasource "foo" and one with
datasource "foo2"
// let's remove the only segment with datasource "foo2"
final DataSegment segmentToRemove = segments.stream()
.filter(segment ->
segment.getDataSource().equals("foo2"))
.findFirst()
.orElse(null);
- Assert.assertNotNull(segmentToRemove);
+ Assertions.assertNotNull(segmentToRemove);
schema.removeSegment(segmentToRemove);
// The following line can cause NPE without segmentMetadata null check in
// SegmentMetadataCache#refreshSegmentsForDataSource
schema.refreshSegments(segments.stream().map(DataSegment::getId).collect(Collectors.toSet()));
- Assert.assertEquals(5, schema.getSegmentMetadataSnapshot().size());
+ Assertions.assertEquals(5, schema.getSegmentMetadataSnapshot().size());
}
@Test
@@ -774,11 +774,11 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.stream()
.map(AvailableSegmentMetadata::getSegment)
.collect(Collectors.toList());
- Assert.assertEquals(6, segments.size());
+ Assertions.assertEquals(6, segments.size());
// verify that dim3 column isn't present in the schema for foo
DatasourceTable.PhysicalDatasourceMetadata fooDs =
schema.getDatasource("foo");
-
Assert.assertTrue(fooDs.getRowSignature().getColumnNames().stream().noneMatch("dim3"::equals));
+
Assertions.assertTrue(fooDs.getRowSignature().getColumnNames().stream().noneMatch("dim3"::equals));
// segments contains two segments with datasource "foo" and one with
datasource "foo2"
// let's remove the only segment with datasource "foo2"
@@ -786,7 +786,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.filter(segment ->
segment.getDataSource().equals("foo2"))
.findFirst()
.orElse(null);
- Assert.assertNotNull(segmentToRemove);
+ Assertions.assertNotNull(segmentToRemove);
schema.removeSegment(segmentToRemove);
// we will add a segment to another datasource and
@@ -800,7 +800,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.size(0)
.build();
- final File tmpDir = temporaryFolder.newFolder();
+ final File tmpDir = newTempFolder();
List<InputRow> rows = ImmutableList.of(
createRow(ImmutableMap.of("t", "2002-01-01", "m1", "1.0", "dim1", "",
"dim3", "c1")),
@@ -827,7 +827,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
walker.add(newSegment, index);
serverView.addSegment(newSegment, ServerType.HISTORICAL);
- Assert.assertTrue(addSegmentLatch.await(1, TimeUnit.SECONDS));
+ Assertions.assertTrue(addSegmentLatch.await(1, TimeUnit.SECONDS));
emitter.verifyValue(Metric.SCHEMA_ROW_SIGNATURE_COLUMN_COUNT,
Map.of(DruidMetrics.DATASOURCE, "foo"), 6L);
@@ -845,7 +845,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.collect(Collectors.toList());
schema.refresh(segments.stream().map(DataSegment::getId).collect(Collectors.toSet()),
dataSourcesToRefresh);
- Assert.assertEquals(6, schema.getSegmentMetadataSnapshot().size());
+ Assertions.assertEquals(6, schema.getSegmentMetadataSnapshot().size());
fooDs = schema.getDatasource("foo");
@@ -854,7 +854,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
// check if the new column present in the added segment is present in the
datasource schema
// ensuring that the schema is rebuilt
-
Assert.assertTrue(fooDs.getRowSignature().getColumnNames().stream().anyMatch("dim3"::equals));
+
Assertions.assertTrue(fooDs.getRowSignature().getColumnNames().stream().anyMatch("dim3"::equals));
}
@Test
@@ -866,19 +866,19 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.stream()
.map(AvailableSegmentMetadata::getSegment)
.collect(Collectors.toList());
- Assert.assertEquals(6, segments.size());
+ Assertions.assertEquals(6, segments.size());
// remove one of the segments with datasource "foo"
final DataSegment segmentToRemove = segments.stream()
.filter(segment ->
segment.getDataSource().equals("foo"))
.findFirst()
.orElse(null);
- Assert.assertNotNull(segmentToRemove);
+ Assertions.assertNotNull(segmentToRemove);
schema.removeSegment(segmentToRemove);
// The following line can cause NPE without segmentMetadata null check in
// SegmentMetadataCache#refreshSegmentsForDataSource
schema.refreshSegments(segments.stream().map(DataSegment::getId).collect(Collectors.toSet()));
- Assert.assertEquals(5, schema.getSegmentMetadataSnapshot().size());
+ Assertions.assertEquals(5, schema.getSegmentMetadataSnapshot().size());
}
/**
@@ -896,13 +896,13 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
public void testLocalSegmentCacheSetsDataSourceAsGlobalAndJoinable() throws
InterruptedException
{
BrokerSegmentMetadataCache schema = buildSchemaMarkAndRefreshLatch();
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
DatasourceTable.PhysicalDatasourceMetadata fooTable =
schema.getDatasource("foo");
- Assert.assertNotNull(fooTable);
- Assert.assertTrue(fooTable.dataSource() instanceof TableDataSource);
- Assert.assertFalse(fooTable.dataSource() instanceof GlobalTableDataSource);
- Assert.assertFalse(fooTable.isJoinable());
- Assert.assertFalse(fooTable.isBroadcast());
+ Assertions.assertNotNull(fooTable);
+ Assertions.assertTrue(fooTable.dataSource() instanceof TableDataSource);
+ Assertions.assertFalse(fooTable.dataSource() instanceof
GlobalTableDataSource);
+ Assertions.assertFalse(fooTable.isJoinable());
+ Assertions.assertFalse(fooTable.isBroadcast());
markDataSourceLatch = new CountDownLatch(1);
refreshLatch = new CountDownLatch(1);
@@ -922,19 +922,19 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
segmentDataSourceNames.add("foo");
joinableDataSourceNames.add("foo");
serverView.addSegment(someNewBrokerSegment, ServerType.BROKER);
- Assert.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
+ Assertions.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for build twice
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for get again, just to make sure table has been updated (latch
counts down just before tables are updated)
refreshLatch = new CountDownLatch(1);
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
fooTable = schema.getDatasource("foo");
- Assert.assertNotNull(fooTable);
- Assert.assertTrue(fooTable.dataSource() instanceof TableDataSource);
- Assert.assertTrue(fooTable.dataSource() instanceof GlobalTableDataSource);
- Assert.assertTrue(fooTable.isJoinable());
- Assert.assertTrue(fooTable.isBroadcast());
+ Assertions.assertNotNull(fooTable);
+ Assertions.assertTrue(fooTable.dataSource() instanceof TableDataSource);
+ Assertions.assertTrue(fooTable.dataSource() instanceof
GlobalTableDataSource);
+ Assertions.assertTrue(fooTable.isJoinable());
+ Assertions.assertTrue(fooTable.isBroadcast());
// now remove it
markDataSourceLatch = new CountDownLatch(1);
@@ -943,33 +943,33 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
segmentDataSourceNames.remove("foo");
serverView.removeSegment(someNewBrokerSegment, ServerType.BROKER);
- Assert.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
+ Assertions.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for build twice
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for get again, just to make sure table has been updated (latch
counts down just before tables are updated)
refreshLatch = new CountDownLatch(1);
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
fooTable = schema.getDatasource("foo");
- Assert.assertNotNull(fooTable);
- Assert.assertTrue(fooTable.dataSource() instanceof TableDataSource);
- Assert.assertFalse(fooTable.dataSource() instanceof GlobalTableDataSource);
- Assert.assertFalse(fooTable.isJoinable());
- Assert.assertFalse(fooTable.isBroadcast());
+ Assertions.assertNotNull(fooTable);
+ Assertions.assertTrue(fooTable.dataSource() instanceof TableDataSource);
+ Assertions.assertFalse(fooTable.dataSource() instanceof
GlobalTableDataSource);
+ Assertions.assertFalse(fooTable.isJoinable());
+ Assertions.assertFalse(fooTable.isBroadcast());
}
@Test
public void testLocalSegmentCacheSetsDataSourceAsBroadcastButNotJoinable()
throws InterruptedException
{
BrokerSegmentMetadataCache schema = buildSchemaMarkAndRefreshLatch();
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
DatasourceTable.PhysicalDatasourceMetadata fooTable =
schema.getDatasource("foo");
- Assert.assertNotNull(fooTable);
- Assert.assertNotNull(fooTable);
- Assert.assertTrue(fooTable.dataSource() instanceof TableDataSource);
- Assert.assertFalse(fooTable.dataSource() instanceof GlobalTableDataSource);
- Assert.assertFalse(fooTable.isJoinable());
- Assert.assertFalse(fooTable.isBroadcast());
+ Assertions.assertNotNull(fooTable);
+ Assertions.assertNotNull(fooTable);
+ Assertions.assertTrue(fooTable.dataSource() instanceof TableDataSource);
+ Assertions.assertFalse(fooTable.dataSource() instanceof
GlobalTableDataSource);
+ Assertions.assertFalse(fooTable.isJoinable());
+ Assertions.assertFalse(fooTable.isBroadcast());
markDataSourceLatch = new CountDownLatch(1);
refreshLatch = new CountDownLatch(1);
@@ -989,12 +989,12 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
segmentDataSourceNames.add("foo");
serverView.addSegment(someNewBrokerSegment, ServerType.BROKER);
- Assert.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
+ Assertions.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for build twice
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for get again, just to make sure table has been updated (latch
counts down just before tables are updated)
refreshLatch = new CountDownLatch(1);
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
emitter.verifyValue(Metric.SCHEMA_ROW_SIGNATURE_COLUMN_COUNT,
Map.of(DruidMetrics.DATASOURCE, "foo"), 6L);
emitter.verifyValue(Metric.SCHEMA_ROW_SIGNATURE_COLUMN_COUNT,
Map.of(DruidMetrics.DATASOURCE, "foo2"), 3L);
@@ -1002,13 +1002,13 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
fooTable = schema.getDatasource("foo");
- Assert.assertNotNull(fooTable);
- Assert.assertTrue(fooTable.dataSource() instanceof TableDataSource);
+ Assertions.assertNotNull(fooTable);
+ Assertions.assertTrue(fooTable.dataSource() instanceof TableDataSource);
// Should not be a GlobalTableDataSource for now, because isGlobal is
couple with joinability. Ideally this will be
// changed in the future and we should expect.
- Assert.assertFalse(fooTable.dataSource() instanceof GlobalTableDataSource);
- Assert.assertTrue(fooTable.isBroadcast());
- Assert.assertFalse(fooTable.isJoinable());
+ Assertions.assertFalse(fooTable.dataSource() instanceof
GlobalTableDataSource);
+ Assertions.assertTrue(fooTable.isBroadcast());
+ Assertions.assertFalse(fooTable.isJoinable());
// now remove it
markDataSourceLatch = new CountDownLatch(1);
@@ -1016,19 +1016,19 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
segmentDataSourceNames.remove("foo");
serverView.removeSegment(someNewBrokerSegment, ServerType.BROKER);
- Assert.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
+ Assertions.assertTrue(markDataSourceLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for build twice
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
// wait for get again, just to make sure table has been updated (latch
counts down just before tables are updated)
refreshLatch = new CountDownLatch(1);
- Assert.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS));
+ Assertions.assertTrue(refreshLatch.await(WAIT_TIMEOUT_SECS,
TimeUnit.SECONDS));
fooTable = schema.getDatasource("foo");
- Assert.assertNotNull(fooTable);
- Assert.assertTrue(fooTable.dataSource() instanceof TableDataSource);
- Assert.assertFalse(fooTable.dataSource() instanceof GlobalTableDataSource);
- Assert.assertFalse(fooTable.isBroadcast());
- Assert.assertFalse(fooTable.isJoinable());
+ Assertions.assertNotNull(fooTable);
+ Assertions.assertTrue(fooTable.dataSource() instanceof TableDataSource);
+ Assertions.assertFalse(fooTable.dataSource() instanceof
GlobalTableDataSource);
+ Assertions.assertFalse(fooTable.isBroadcast());
+ Assertions.assertFalse(fooTable.isJoinable());
}
/**
@@ -1112,9 +1112,9 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
Set<SegmentId> segments = new HashSet<>();
Set<String> datasources = new HashSet<>();
datasources.add("wat");
- Assert.assertNull(schema.getDatasource("wat"));
+ Assertions.assertNull(schema.getDatasource("wat"));
schema.refresh(segments, datasources);
- Assert.assertNull(schema.getDatasource("wat"));
+ Assertions.assertNull(schema.getDatasource("wat"));
}
@Test
@@ -1156,7 +1156,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
);
serverView.addSegment(segments.get(0), ServerType.HISTORICAL);
serverView.addSegment(segments.get(1), ServerType.INDEXER_EXECUTOR);
- Assert.assertTrue(addSegmentLatch.await(1, TimeUnit.SECONDS));
+ Assertions.assertTrue(addSegmentLatch.await(1, TimeUnit.SECONDS));
schema.refresh(segments.stream().map(DataSegment::getId).collect(Collectors.toSet()),
Sets.newHashSet(dataSource));
emitter.verifyEmitted(Metric.REFRESH_DURATION_MILLIS,
Map.of(DruidMetrics.DATASOURCE, dataSource), 1);
@@ -1192,7 +1192,7 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
schema.refresh(segments.stream().map(DataSegment::getId).collect(Collectors.toSet()),
Collections.singleton("foo"));
- Assert.assertNull(schema.getDatasource("foo"));
+ Assertions.assertNull(schema.getDatasource("foo"));
}
@Test
@@ -1246,12 +1246,12 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
.findAny()
.orElse(null);
- Assert.assertNotNull(historicalServer);
+ Assertions.assertNotNull(historicalServer);
final DruidServerMetadata historicalServerMetadata =
historicalServer.getMetadata();
schema.addSegment(historicalServerMetadata, segment);
schema.addSegment(historicalServerMetadata, tombstone);
-
Assert.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
+
Assertions.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
List<SegmentId> segmentIterable = ImmutableList.of(segment.getId(),
tombstone.getId());
@@ -1293,19 +1293,19 @@ public class BrokerSegmentMetadataCacheTest extends
BrokerSegmentMetadataCacheTe
EasyMock.verify(factoryMock, lifecycleMock);
// Verify that datasource schema building logic doesn't mark the tombstone
segment for refresh
-
Assert.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
+
Assertions.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
AvailableSegmentMetadata availableSegmentMetadata =
schema.getAvailableSegmentMetadata("test", tombstone.getId());
- Assert.assertNotNull(availableSegmentMetadata);
+ Assertions.assertNotNull(availableSegmentMetadata);
// fetching metadata for tombstone segment shouldn't mark it for refresh
-
Assert.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
+
Assertions.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
Set<AvailableSegmentMetadata> metadatas = new HashSet<>();
schema.iterateSegmentMetadata().forEachRemaining(metadatas::add);
- Assert.assertEquals(1, metadatas.stream().filter(metadata ->
metadata.getSegment().isTombstone()).count());
+ Assertions.assertEquals(1, metadatas.stream().filter(metadata ->
metadata.getSegment().isTombstone()).count());
// iterating over entire metadata doesn't cause tombstone to be marked for
refresh
-
Assert.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
+
Assertions.assertFalse(schema.getSegmentsNeedingRefresh().contains(tombstone.getId()));
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTestBase.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTestBase.java
index 522485ad0f3..1b8a0b693c5 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTestBase.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/BrokerSegmentMetadataCacheTestBase.java
@@ -22,6 +22,7 @@ package org.apache.druid.sql.calcite.schema;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import org.apache.druid.client.ImmutableDruidServer;
+import org.apache.druid.java.util.common.FileUtils;
import org.apache.druid.query.DataSource;
import org.apache.druid.query.GlobalTableDataSource;
import org.apache.druid.segment.join.JoinConditionAnalysis;
@@ -34,7 +35,10 @@ import
org.apache.druid.server.SpecificSegmentsQuerySegmentWalker;
import org.apache.druid.sql.calcite.util.TestTimelineServerView;
import org.apache.druid.timeline.DataSegment;
import org.easymock.EasyMock;
+import org.junit.jupiter.api.io.TempDir;
+import java.io.File;
+import java.nio.file.Path;
import java.util.List;
import java.util.Optional;
import java.util.Set;
@@ -50,8 +54,17 @@ public class BrokerSegmentMetadataCacheTestBase extends
SegmentMetadataCacheTest
public SpecificSegmentsQuerySegmentWalker walker;
public TestTimelineServerView serverView;
+ @TempDir
+ private Path temporaryDirectory;
+
+ protected File newTempFolder()
+ {
+ return FileUtils.createTempDirInLocation(temporaryDirectory,
"metadata-cache-");
+ }
+
public void setUp() throws Exception
{
+ temporaryFolder.create();
setUpData();
setUpCommon();
@@ -97,4 +110,11 @@ public class BrokerSegmentMetadataCacheTestBase extends
SegmentMetadataCacheTest
serverView = new TestTimelineServerView(walker.getSegments(),
realtimeSegments);
druidServers = serverView.getDruidServers();
}
+
+ @Override
+ public void tearDown() throws Exception
+ {
+ super.tearDown();
+ temporaryFolder.delete();
+ }
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/DruidSchemaNoDataInitTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/DruidSchemaNoDataInitTest.java
index 3412015a8ae..dd8c30e94e2 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/DruidSchemaNoDataInitTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/DruidSchemaNoDataInitTest.java
@@ -37,7 +37,7 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase;
import org.apache.druid.sql.calcite.util.CalciteTests;
import org.apache.druid.sql.calcite.util.TestTimelineServerView;
import org.easymock.EasyMock;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.Collections;
@@ -72,7 +72,7 @@ public class DruidSchemaNoDataInitTest extends CalciteTestBase
cache.awaitInitialization();
final DruidSchema druidSchema = new DruidSchema(cache, null,
CatalogResolver.NULL_RESOLVER);
- Assert.assertEquals(ImmutableSet.of(), druidSchema.getTableNames());
+ Assertions.assertEquals(ImmutableSet.of(), druidSchema.getTableNames());
}
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java
index 06e02fe1ae6..8c540cbd1a6 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/InformationSchemaTest.java
@@ -45,7 +45,7 @@ import org.apache.druid.sql.calcite.table.RowSignatures;
import org.apache.druid.sql.calcite.util.CalciteTests;
import org.apache.druid.sql.calcite.util.QueryFrameworkUtils;
import org.apache.druid.sql.calcite.util.SqlTestFramework;
-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,7 +87,7 @@ public class InformationSchemaTest extends
BaseCalciteQueryTest
@Test
public void testGetTableNamesMap()
{
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("SCHEMATA", "TABLES", "COLUMNS", "ROUTINES"),
informationSchema.getTableNames()
);
@@ -102,19 +102,21 @@ public class InformationSchemaTest extends
BaseCalciteQueryTest
List<Object[]> rows = routinesTable.scan(dataContext).toList();
- Assert.assertTrue("There should at least be 1 built-in function that gets
statically loaded by default",
- rows.size() > 0);
+ Assertions.assertTrue(
+ rows.size() > 0,
+ "There should at least be 1 built-in function that gets statically
loaded by default"
+ );
RelDataType rowType = routinesTable.getRowType(new JavaTypeFactoryImpl());
- Assert.assertEquals(6, rowType.getFieldCount());
+ Assertions.assertEquals(6, rowType.getFieldCount());
for (Object[] row : rows) {
- Assert.assertEquals(rowType.getFieldCount(), row.length);
- Assert.assertEquals("druid", row[0]);
- Assert.assertEquals("INFORMATION_SCHEMA", row[1]);
- Assert.assertNotNull(row[2]);
- Assert.assertNotNull(row[3]);
+ Assertions.assertEquals(rowType.getFieldCount(), row.length);
+ Assertions.assertEquals("druid", row[0]);
+ Assertions.assertEquals("INFORMATION_SCHEMA", row[1]);
+ Assertions.assertNotNull(row[2]);
+ Assertions.assertNotNull(row[3]);
String isAggregator = row[4].toString();
- Assert.assertTrue(isAggregator.contains("YES") ||
isAggregator.contains("NO"));
+ Assertions.assertTrue(isAggregator.contains("YES") ||
isAggregator.contains("NO"));
// nothing to validate for signatures as it may be not be present if
operandTypeChecker is not defined.
}
}
@@ -135,14 +137,17 @@ public class InformationSchemaTest extends
BaseCalciteQueryTest
List<Object[]> rows = routinesTable.scan(dataContext).toList();
- Assert.assertNotNull(rows);
- Assert.assertEquals("There should be exactly 2 rows; any non-function
syntax operator should get filtered out",
- 2, rows.size());
+ Assertions.assertNotNull(rows);
+ Assertions.assertEquals(
+ 2,
+ rows.size(),
+ "There should be exactly 2 rows; any non-function syntax operator
should get filtered out"
+ );
Object[] expectedRow1 = {"druid", "INFORMATION_SCHEMA", "FOO", "FUNCTION",
"NO", "'FOO([<ANY>])'"};
- Assert.assertTrue(rows.stream().anyMatch(row -> Arrays.equals(row,
expectedRow1)));
+ Assertions.assertTrue(rows.stream().anyMatch(row -> Arrays.equals(row,
expectedRow1)));
Object[] expectedRow2 = {"druid", "INFORMATION_SCHEMA", "BAR", "FUNCTION",
"NO", "'BAR(<INTEGER>, <INTEGER>)'"};
- Assert.assertTrue(rows.stream().anyMatch(row -> Arrays.equals(row,
expectedRow2)));
+ Assertions.assertTrue(rows.stream().anyMatch(row -> Arrays.equals(row,
expectedRow2)));
}
@Test
@@ -159,8 +164,8 @@ public class InformationSchemaTest extends
BaseCalciteQueryTest
List<Object[]> rows = routinesTable.scan(dataContext).toList();
- Assert.assertNotNull(rows);
- Assert.assertEquals(0, rows.size());
+ Assertions.assertNotNull(rows);
+ Assertions.assertEquals(0, rows.size());
}
private static Set<SqlOperatorConversion>
customOperatorsToOperatorConversions()
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedDruidSchemaTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedDruidSchemaTest.java
index 15e4e429ef4..13b0da1540f 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedDruidSchemaTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedDruidSchemaTest.java
@@ -22,7 +22,7 @@ package org.apache.druid.sql.calcite.schema;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
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;
@@ -46,12 +46,12 @@ public class NamedDruidSchemaTest extends CalciteTestBase
@Test
public void testGetSchemaNameShouldReturnName()
{
- Assert.assertEquals(SCHEMA_NAME, target.getSchemaName());
+ Assertions.assertEquals(SCHEMA_NAME, target.getSchemaName());
}
@Test
public void testGetSchemaShouldReturnSchema()
{
- Assert.assertEquals(druidSchema, target.getSchema());
+ Assertions.assertEquals(druidSchema, target.getSchema());
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedLookupSchemaTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedLookupSchemaTest.java
index 1e4bd396b92..5473103559f 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedLookupSchemaTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedLookupSchemaTest.java
@@ -22,7 +22,7 @@ package org.apache.druid.sql.calcite.schema;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
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;
@@ -46,12 +46,12 @@ public class NamedLookupSchemaTest extends CalciteTestBase
@Test
public void testGetSchemaNameShouldReturnName()
{
- Assert.assertEquals(SCHEMA_NAME, target.getSchemaName());
+ Assertions.assertEquals(SCHEMA_NAME, target.getSchemaName());
}
@Test
public void testGetSchemaShouldReturnSchema()
{
- Assert.assertEquals(lookupSchema, target.getSchema());
+ Assertions.assertEquals(lookupSchema, target.getSchema());
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedSystemSchemaTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedSystemSchemaTest.java
index 31cdf8d710c..9c80ea1dd08 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedSystemSchemaTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/NamedSystemSchemaTest.java
@@ -24,7 +24,7 @@ import org.apache.druid.sql.calcite.planner.PlannerConfig;
import org.apache.druid.sql.calcite.util.CalciteTestBase;
import org.easymock.EasyMock;
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;
@@ -49,13 +49,13 @@ public class NamedSystemSchemaTest extends CalciteTestBase
@Test
public void testGetSchemaNameShouldReturnName()
{
- Assert.assertEquals(SCHEMA_NAME, target.getSchemaName());
+ Assertions.assertEquals(SCHEMA_NAME, target.getSchemaName());
}
@Test
public void testGetSchemaShouldReturnSchema()
{
- Assert.assertEquals(systemSchema, target.getSchema());
+ Assertions.assertEquals(systemSchema, target.getSchema());
}
@Test
@@ -63,7 +63,7 @@ public class NamedSystemSchemaTest extends CalciteTestBase
{
EasyMock.expect(plannerConfig.isAuthorizeSystemTablesDirectly()).andReturn(false).once();
EasyMock.replay(plannerConfig);
- Assert.assertNull(target.getSchemaResourceType("servers"));
+ Assertions.assertNull(target.getSchemaResourceType("servers"));
EasyMock.verify(plannerConfig);
}
@@ -72,7 +72,7 @@ public class NamedSystemSchemaTest extends CalciteTestBase
{
EasyMock.expect(plannerConfig.isAuthorizeSystemTablesDirectly()).andReturn(true).once();
EasyMock.replay(plannerConfig);
- Assert.assertEquals(ResourceType.SYSTEM_TABLE,
target.getSchemaResourceType("servers"));
+ Assertions.assertEquals(ResourceType.SYSTEM_TABLE,
target.getSchemaResourceType("servers"));
EasyMock.verify(plannerConfig);
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/PhysicalDataSourceMetadataFactoryTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/PhysicalDataSourceMetadataFactoryTest.java
index 919eb94a4cf..03f40a2f6e3 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/PhysicalDataSourceMetadataFactoryTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/PhysicalDataSourceMetadataFactoryTest.java
@@ -31,9 +31,9 @@ import org.apache.druid.segment.loading.SegmentCacheManager;
import org.apache.druid.server.SegmentManager;
import org.apache.druid.sql.calcite.table.DatasourceTable;
import org.easymock.EasyMock;
-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.Optional;
import java.util.Set;
@@ -47,7 +47,7 @@ public class PhysicalDataSourceMetadataFactoryTest
private PhysicalDatasourceMetadataFactory datasourceMetadataFactory;
- @Before
+ @BeforeEach
public void setUp()
{
segmentDataSourceNames = Sets.newConcurrentHashSet();
@@ -102,15 +102,15 @@ public class PhysicalDataSourceMetadataFactoryTest
.build();
DatasourceTable.PhysicalDatasourceMetadata fooDs =
datasourceMetadataFactory.build("foo", fooSignature);
- Assert.assertTrue(fooDs.isJoinable());
- Assert.assertTrue(fooDs.isBroadcast());
- Assert.assertEquals(fooDs.dataSource().getName(), "foo");
- Assert.assertEquals(fooDs.getRowSignature(), fooSignature);
+ Assertions.assertTrue(fooDs.isJoinable());
+ Assertions.assertTrue(fooDs.isBroadcast());
+ Assertions.assertEquals(fooDs.dataSource().getName(), "foo");
+ Assertions.assertEquals(fooDs.getRowSignature(), fooSignature);
DatasourceTable.PhysicalDatasourceMetadata barDs =
datasourceMetadataFactory.build("bar", barSignature);
- Assert.assertFalse(barDs.isJoinable());
- Assert.assertFalse(barDs.isBroadcast());
- Assert.assertEquals(barDs.dataSource().getName(), "bar");
- Assert.assertEquals(barDs.getRowSignature(), barSignature);
+ Assertions.assertFalse(barDs.isJoinable());
+ Assertions.assertFalse(barDs.isBroadcast());
+ Assertions.assertEquals(barDs.dataSource().getName(), "bar");
+ Assertions.assertEquals(barDs.getRowSignature(), barSignature);
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/RootSchemaProviderTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/RootSchemaProviderTest.java
index a43a3f24f4f..eb67dde69fd 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/RootSchemaProviderTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/RootSchemaProviderTest.java
@@ -26,7 +26,7 @@ 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;
@@ -74,13 +74,13 @@ public class RootSchemaProviderTest extends CalciteTestBase
public void testGetShouldReturnRootSchemaWithProvidedSchemasRegistered()
{
DruidSchemaCatalog rootSchema = target.get();
- Assert.assertEquals("", rootSchema.getRootSchema().getName());
- Assert.assertFalse(rootSchema.getRootSchema().isCacheEnabled());
+ Assertions.assertEquals("", rootSchema.getRootSchema().getName());
+ Assertions.assertFalse(rootSchema.getRootSchema().isCacheEnabled());
// metadata schema should not be added
- Assert.assertEquals(druidSchemas.size(),
rootSchema.getSubSchemaNames().size());
+ Assertions.assertEquals(druidSchemas.size(),
rootSchema.getSubSchemaNames().size());
- Assert.assertEquals(schema1,
rootSchema.getSubSchema(SCHEMA_1).unwrap(schema1.getClass()));
- Assert.assertEquals(schema2,
rootSchema.getSubSchema(SCHEMA_2).unwrap(schema2.getClass()));
+ Assertions.assertEquals(schema1,
rootSchema.getSubSchema(SCHEMA_1).unwrap(schema1.getClass()));
+ Assertions.assertEquals(schema2,
rootSchema.getSubSchema(SCHEMA_2).unwrap(schema2.getClass()));
}
@Test
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaFiltersTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaFiltersTest.java
index f8344db8ede..fd4269ce39b 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaFiltersTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaFiltersTest.java
@@ -27,9 +27,9 @@ import org.apache.calcite.rex.RexBuilder;
import org.apache.calcite.rex.RexLiteral;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-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.Map;
import java.util.Set;
@@ -54,7 +54,7 @@ public class SystemSchemaFiltersTest
private RexNode bRef;
private RexNode otherRef;
- @Before
+ @BeforeEach
public void setUp()
{
rexBuilder = new RexBuilder(new JavaTypeFactoryImpl());
@@ -71,7 +71,7 @@ public class SystemSchemaFiltersTest
public void testEquals()
{
// col = 'foo'
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo"),
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
aRef, foo)),
@@ -84,7 +84,7 @@ public class SystemSchemaFiltersTest
public void testEqualsReversedOperands()
{
// 'foo' = col
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo"),
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
foo, aRef)),
@@ -97,7 +97,7 @@ public class SystemSchemaFiltersTest
public void testIn()
{
// col IN ('foo', 'bar') -- Calcite normalizes IN to a SEARCH over a
points Sarg
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo", "bar"),
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeIn(aRef, ImmutableList.of(foo,
bar))),
@@ -110,7 +110,7 @@ public class SystemSchemaFiltersTest
public void testOrOfEqualities()
{
// col = 'foo' OR col = 'bar'
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo", "bar"),
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(
@@ -127,7 +127,7 @@ public class SystemSchemaFiltersTest
public void testOrWithUnextractableDisjunctReturnsNull()
{
// col = 'foo' OR col > 'bar' -- one disjunct cannot bound the set, so the
whole OR is unbounded
- Assert.assertNull(
+ Assertions.assertNull(
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(
SqlStdOperatorTable.OR,
@@ -143,7 +143,7 @@ public class SystemSchemaFiltersTest
public void testTopLevelConjunctsIntersect()
{
// A top-level filter list is implicitly ANDed: IN ('foo','bar') AND IN
('bar','baz') => {'bar'}
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("bar"),
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(
@@ -159,7 +159,7 @@ public class SystemSchemaFiltersTest
public void testNestedAndConjunctsIntersect()
{
// A whole WHERE passed as a single AND(...) RexCall: IN ('foo','bar') AND
IN ('bar','baz') => {'bar'}
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("bar"),
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(
@@ -176,7 +176,7 @@ public class SystemSchemaFiltersTest
public void testAndIgnoresNonMatchingConjunct()
{
// col_a = 'foo' AND col_other = 'foo' => {'foo'} (the non-target conjunct
is ignored)
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo"),
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(
@@ -193,7 +193,7 @@ public class SystemSchemaFiltersTest
public void testAndWithNoConstraintOnColumnReturnsNull()
{
// AND of predicates that never touch the target column => null (full scan
retained)
- Assert.assertNull(
+ Assertions.assertNull(
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(
SqlStdOperatorTable.AND,
@@ -208,14 +208,14 @@ public class SystemSchemaFiltersTest
@Test
public void testEmptyFilterListReturnsNull()
{
-
Assert.assertNull(SystemSchemaFilters.extractColumnValues(ImmutableList.of(),
COL_A));
+
Assertions.assertNull(SystemSchemaFilters.extractColumnValues(ImmutableList.of(),
COL_A));
}
@Test
public void testRangePredicateReturnsNull()
{
// col > 'foo' -- a range cannot bound the value set
- Assert.assertNull(
+ Assertions.assertNull(
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN, aRef,
foo)),
COL_A
@@ -226,7 +226,7 @@ public class SystemSchemaFiltersTest
@Test
public void testEqualityOnOtherColumnReturnsNull()
{
- Assert.assertNull(
+ Assertions.assertNull(
SystemSchemaFilters.extractColumnValues(
ImmutableList.of(rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
otherRef, foo)),
COL_A
@@ -238,7 +238,7 @@ public class SystemSchemaFiltersTest
public void testNonRexCallNodeReturnsNull()
{
// A bare input ref (not a RexCall) constrains nothing.
-
Assert.assertNull(SystemSchemaFilters.extractColumnValues(ImmutableList.of(aRef),
COL_A));
+
Assertions.assertNull(SystemSchemaFilters.extractColumnValues(ImmutableList.of(aRef),
COL_A));
}
@Test
@@ -252,7 +252,7 @@ public class SystemSchemaFiltersTest
);
final Map<Integer, Set<String>> result =
SystemSchemaFilters.extractColumnValues(ImmutableList.of(filter),
COL_A, COL_B);
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableMap.of(
COL_A, ImmutableSet.of("foo"),
COL_B, ImmutableSet.of("bar", "baz")
@@ -268,7 +268,7 @@ public class SystemSchemaFiltersTest
final RexNode filter = rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
aRef, foo);
final Map<Integer, Set<String>> result =
SystemSchemaFilters.extractColumnValues(ImmutableList.of(filter),
COL_A, COL_B);
- Assert.assertEquals(ImmutableMap.of(COL_A, ImmutableSet.of("foo")),
result);
- Assert.assertFalse(result.containsKey(COL_B));
+ Assertions.assertEquals(ImmutableMap.of(COL_A, ImmutableSet.of("foo")),
result);
+ Assertions.assertFalse(result.containsKey(COL_B));
}
}
diff --git
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
index 8ba8c912743..837aef7a050 100644
---
a/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
+++
b/sql/src/test/java/org/apache/druid/sql/calcite/schema/SystemSchemaTest.java
@@ -28,7 +28,6 @@ import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
-import junitparams.converters.Nullable;
import org.apache.calcite.DataContext;
import org.apache.calcite.adapter.java.JavaTypeFactory;
import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
@@ -132,13 +131,15 @@ import org.jboss.netty.handler.codec.http.HttpResponse;
import org.jboss.netty.handler.codec.http.HttpResponseStatus;
import org.jboss.netty.handler.codec.http.HttpVersion;
import org.joda.time.DateTime;
-import org.junit.Assert;
import org.junit.jupiter.api.AfterAll;
+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.annotation.Nullable;
+
import java.io.File;
import java.io.IOException;
import java.net.URI;
@@ -570,13 +571,13 @@ public class SystemSchemaTest extends CalciteTestBase
@Test
public void testGetTableMap()
{
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("segments", "servers", "server_segments", "tasks",
"supervisors", "server_properties"),
schema.getTableNames()
);
final Map<String, Table> tableMap = schema.getTableMap();
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("segments", "servers", "server_segments", "tasks",
"supervisors", "server_properties"),
tableMap.keySet()
);
@@ -584,28 +585,28 @@ public class SystemSchemaTest extends CalciteTestBase
final RelDataType rowType = segmentsTable.getRowType(new
JavaTypeFactoryImpl());
final List<RelDataTypeField> fields = rowType.getFieldList();
- Assert.assertEquals(20, fields.size());
+ Assertions.assertEquals(20, fields.size());
final SystemSchema.TasksTable tasksTable = (SystemSchema.TasksTable)
schema.getTableMap().get("tasks");
final RelDataType sysRowType = tasksTable.getRowType(new
JavaTypeFactoryImpl());
final List<RelDataTypeField> sysFields = sysRowType.getFieldList();
- Assert.assertEquals(14, sysFields.size());
+ Assertions.assertEquals(14, sysFields.size());
- Assert.assertEquals("task_id", sysFields.get(0).getName());
- Assert.assertEquals(SqlTypeName.VARCHAR,
sysFields.get(0).getType().getSqlTypeName());
+ Assertions.assertEquals("task_id", sysFields.get(0).getName());
+ Assertions.assertEquals(SqlTypeName.VARCHAR,
sysFields.get(0).getType().getSqlTypeName());
final SystemSchema.ServersTable serversTable = (SystemSchema.ServersTable)
schema.getTableMap().get("servers");
final RelDataType serverRowType = serversTable.getRowType(new
JavaTypeFactoryImpl());
final List<RelDataTypeField> serverFields = serverRowType.getFieldList();
- Assert.assertEquals(16, serverFields.size());
- Assert.assertEquals("server", serverFields.get(0).getName());
- Assert.assertEquals(SqlTypeName.VARCHAR,
serverFields.get(0).getType().getSqlTypeName());
+ Assertions.assertEquals(16, serverFields.size());
+ Assertions.assertEquals("server", serverFields.get(0).getName());
+ Assertions.assertEquals(SqlTypeName.VARCHAR,
serverFields.get(0).getType().getSqlTypeName());
final SystemServerPropertiesTable propertiesTable =
(SystemServerPropertiesTable) schema.getTableMap()
.get("server_properties");
final RelDataType propertiesRowType = propertiesTable.getRowType(new
JavaTypeFactoryImpl());
final List<RelDataTypeField> propertiesFields =
propertiesRowType.getFieldList();
- Assert.assertEquals(6, propertiesFields.size());
+ Assertions.assertEquals(6, propertiesFields.size());
}
@Test
@@ -621,25 +622,25 @@ public class SystemSchemaTest extends CalciteTestBase
final RexNode sizeRef = rexBuilder.makeInputRef(foo.getType(), 4);
// datasource = 'foo'
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo"),
SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, dsRef, foo)))
);
// 'foo' = datasource (reversed operands)
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo"),
SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, foo, dsRef)))
);
// datasource IN ('foo', 'bar')
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo", "bar"),
SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeIn(dsRef, ImmutableList.of(foo, bar))))
);
// datasource = 'foo' OR datasource = 'bar'
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo", "bar"),
SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(
@@ -648,24 +649,24 @@ public class SystemSchemaTest extends CalciteTestBase
rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, dsRef, bar))))
);
// ANDed conjuncts intersect: IN ('foo','bar') AND IN ('bar','baz') =>
{'bar'}
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("bar"),
SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeIn(dsRef, ImmutableList.of(foo, bar)),
rexBuilder.makeIn(dsRef, ImmutableList.of(bar, baz))))
);
// No filters => null (full scan retained)
- Assert.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of()));
+
Assertions.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of()));
// Range predicate on datasource cannot bound the scan => null
- Assert.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of(
+ Assertions.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN, dsRef, foo))));
// Equality on a non-datasource column => null
- Assert.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of(
+ Assertions.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, sizeRef, foo))));
// Compound predicate passed as a single AND(...) RexCall (as Calcite's
filter-scan rule may do):
// datasource = 'foo' AND <non-datasource predicate> => {foo} (the
non-datasource conjunct is ignored)
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("foo"),
SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(
@@ -674,7 +675,7 @@ public class SystemSchemaTest extends CalciteTestBase
rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, sizeRef,
foo))))
);
// AND of two datasource constraints intersects: IN ('foo','bar') AND IN
('bar','baz') => {'bar'}
- Assert.assertEquals(
+ Assertions.assertEquals(
ImmutableSet.of("bar"),
SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(
@@ -683,7 +684,7 @@ public class SystemSchemaTest extends CalciteTestBase
rexBuilder.makeIn(dsRef, ImmutableList.of(bar, baz)))))
);
// AND with no datasource conjunct => null (full scan retained)
- Assert.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of(
+ Assertions.assertNull(SegmentsTable.getDataSourceFilter(ImmutableList.of(
rexBuilder.makeCall(
SqlStdOperatorTable.AND,
rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, sizeRef, foo),
@@ -710,7 +711,7 @@ public class SystemSchemaTest extends CalciteTestBase
rows.sort((Object[] row1, Object[] row2) -> ((Comparable)
row1[0]).compareTo(row2[0]));
// total segments = 8
- Assert.assertEquals(8, rows.size());
+ Assertions.assertEquals(8, rows.size());
// Verify value types.
verifyTypes(rows, SystemSchema.SEGMENTS_SIGNATURE);
@@ -725,7 +726,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", "[\"proj1\",\"proj2\"]",
null, 2L
};
- Assert.assertArrayEquals(segment1Expected, rows.get(0));
+ Assertions.assertArrayEquals(segment1Expected, rows.get(0));
Object[] segment2Expected = new Object[]{
// segment_id, datasource
"test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2",
"test2",
@@ -736,7 +737,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", null, null, 0L
};
- Assert.assertArrayEquals(segment2Expected, rows.get(1));
+ Assertions.assertArrayEquals(segment2Expected, rows.get(1));
//segment test3 is unpublished and has a NumberedShardSpec with
partitionNum = 2, is served by historical but unpublished or unused
Object[] segment3Expected = new Object[]{
// segment_id, datasource
@@ -748,7 +749,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", null, null, -1L
};
- Assert.assertArrayEquals(segment3Expected, rows.get(2));
+ Assertions.assertArrayEquals(segment3Expected, rows.get(2));
// segments test4, test5 are not published but available (realtime
segments)
Object[] segment4Expected = new Object[]{
// segment_id, datasource
@@ -760,7 +761,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", null, null, -1L
};
- Assert.assertArrayEquals(segment4Expected, rows.get(3));
+ Assertions.assertArrayEquals(segment4Expected, rows.get(3));
Object[] segment5Expected = new Object[]{
// segment_id, datasource
"test5_2015-01-01T00:00:00.000Z_2016-01-01T00:00:00.000Z_version5",
"test5",
@@ -771,7 +772,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", null, null, -1L
};
- Assert.assertArrayEquals(segment5Expected, rows.get(4));
+ Assertions.assertArrayEquals(segment5Expected, rows.get(4));
// wikipedia segment 1 and segment 2 are published and unavailable and
compacted, num_replicas is 0
Object[] wikiSegment1Expected = new Object[]{
@@ -784,7 +785,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", null,
MAPPER.writeValueAsString(expectedCompactionState), 2L
};
- Assert.assertArrayEquals(wikiSegment1Expected, rows.get(5));
+ Assertions.assertArrayEquals(wikiSegment1Expected, rows.get(5));
Object[] wikiSegment2Expected = new Object[]{
// segment_id, datasource
"wikipedia2_2008-01-01T00:00:00.000Z_2009-01-01T00:00:00.000Z_version2",
"wikipedia2",
@@ -795,7 +796,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", null,
MAPPER.writeValueAsString(expectedCompactionState), 0L
};
- Assert.assertArrayEquals(wikiSegment2Expected, rows.get(6));
+ Assertions.assertArrayEquals(wikiSegment2Expected, rows.get(6));
// wikipedia segment 3 are not compacted, and is projection aware.
Object[] wikiSegment3Expected = new Object[]{
// segment_id, datasource
@@ -807,7 +808,7 @@ public class SystemSchemaTest extends CalciteTestBase
// dimensions, metrics, projections, last_compaction_state,
replication_factor
"[\"dim1\",\"dim2\"]", "[\"met1\",\"met2\"]", "[]", null, 2L
};
- Assert.assertArrayEquals(wikiSegment3Expected, rows.get(7));
+ Assertions.assertArrayEquals(wikiSegment3Expected, rows.get(7));
}
@Test
@@ -842,31 +843,31 @@ public class SystemSchemaTest extends CalciteTestBase
// segments test4, test5 are not published but available (realtime
segments)
// segment test2 is both published and served by a realtime server.
- Assert.assertEquals(8, rows.size());
+ Assertions.assertEquals(8, rows.size());
- Assert.assertNull(null, rows.get(0)[0]);
-
Assert.assertEquals("test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1",
rows.get(0)[1]);
+ Assertions.assertNull(rows.get(0)[0]);
+
Assertions.assertEquals("test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1",
rows.get(0)[1]);
- Assert.assertNull(null, rows.get(1)[0]);
-
Assert.assertEquals("test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2",
rows.get(1)[1]);
+ Assertions.assertNull(rows.get(1)[0]);
+
Assertions.assertEquals("test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2",
rows.get(1)[1]);
- Assert.assertNull(null, rows.get(2)[0]);
-
Assert.assertEquals("test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3_2",
rows.get(2)[1]);
+ Assertions.assertNull(rows.get(2)[0]);
+
Assertions.assertEquals("test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3_2",
rows.get(2)[1]);
- Assert.assertNull(null, rows.get(3)[0]);
-
Assert.assertEquals("test4_2014-01-01T00:00:00.000Z_2015-01-01T00:00:00.000Z_version4",
rows.get(3)[1]);
+ Assertions.assertNull(rows.get(3)[0]);
+
Assertions.assertEquals("test4_2014-01-01T00:00:00.000Z_2015-01-01T00:00:00.000Z_version4",
rows.get(3)[1]);
- Assert.assertNull(null, rows.get(4)[0]);
-
Assert.assertEquals("test5_2015-01-01T00:00:00.000Z_2016-01-01T00:00:00.000Z_version5",
rows.get(4)[1]);
+ Assertions.assertNull(rows.get(4)[0]);
+
Assertions.assertEquals("test5_2015-01-01T00:00:00.000Z_2016-01-01T00:00:00.000Z_version5",
rows.get(4)[1]);
- Assert.assertEquals(MAPPER.writeValueAsString(expectedCompactionState),
rows.get(5)[0]);
-
Assert.assertEquals("wikipedia1_2007-01-01T00:00:00.000Z_2008-01-01T00:00:00.000Z_version1",
rows.get(5)[1]);
+
Assertions.assertEquals(MAPPER.writeValueAsString(expectedCompactionState),
rows.get(5)[0]);
+
Assertions.assertEquals("wikipedia1_2007-01-01T00:00:00.000Z_2008-01-01T00:00:00.000Z_version1",
rows.get(5)[1]);
- Assert.assertEquals(MAPPER.writeValueAsString(expectedCompactionState),
rows.get(6)[0]);
-
Assert.assertEquals("wikipedia2_2008-01-01T00:00:00.000Z_2009-01-01T00:00:00.000Z_version2",
rows.get(6)[1]);
+
Assertions.assertEquals(MAPPER.writeValueAsString(expectedCompactionState),
rows.get(6)[0]);
+
Assertions.assertEquals("wikipedia2_2008-01-01T00:00:00.000Z_2009-01-01T00:00:00.000Z_version2",
rows.get(6)[1]);
- Assert.assertNull(null, rows.get(7)[0]);
-
Assert.assertEquals("wikipedia3_2009-01-01T00:00:00.000Z_2010-01-01T00:00:00.000Z_version3",
rows.get(7)[1]);
+ Assertions.assertNull(rows.get(7)[0]);
+
Assertions.assertEquals("wikipedia3_2009-01-01T00:00:00.000Z_2010-01-01T00:00:00.000Z_version3",
rows.get(7)[1]);
// Verify value types.
verifyTypes(
@@ -1270,9 +1271,9 @@ public class SystemSchemaTest extends CalciteTestBase
availableProcessors,
totalMemory
));
- Assert.assertEquals(expectedRows.size(), rows.size());
+ Assertions.assertEquals(expectedRows.size(), rows.size());
for (int i = 0; i < rows.size(); i++) {
- Assert.assertArrayEquals(expectedRows.get(i), rows.get(i));
+ Assertions.assertArrayEquals(expectedRows.get(i), rows.get(i));
}
// Verify value types.
@@ -1359,27 +1360,27 @@ public class SystemSchemaTest extends CalciteTestBase
// server2:1234 |
test5_2017-01-01T00:00:00.000Z_2018-01-01T00:00:00.000Z_version5(segment5)
final List<Object[]> rows = serverSegmentsTable.scan(dataContext).toList();
- Assert.assertEquals(5, rows.size());
+ Assertions.assertEquals(5, rows.size());
Object[] row0 = rows.get(0);
- Assert.assertEquals("localhost:0000", row0[0]);
-
Assert.assertEquals("test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1",
row0[1].toString());
+ Assertions.assertEquals("localhost:0000", row0[0]);
+
Assertions.assertEquals("test1_2010-01-01T00:00:00.000Z_2011-01-01T00:00:00.000Z_version1",
row0[1].toString());
Object[] row1 = rows.get(1);
- Assert.assertEquals("localhost:0000", row1[0]);
-
Assert.assertEquals("test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2",
row1[1].toString());
+ Assertions.assertEquals("localhost:0000", row1[0]);
+
Assertions.assertEquals("test2_2011-01-01T00:00:00.000Z_2012-01-01T00:00:00.000Z_version2",
row1[1].toString());
Object[] row2 = rows.get(2);
- Assert.assertEquals("server2:1234", row2[0]);
-
Assert.assertEquals("test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3_2",
row2[1].toString());
+ Assertions.assertEquals("server2:1234", row2[0]);
+
Assertions.assertEquals("test3_2012-01-01T00:00:00.000Z_2013-01-01T00:00:00.000Z_version3_2",
row2[1].toString());
Object[] row3 = rows.get(3);
- Assert.assertEquals("server2:1234", row3[0]);
-
Assert.assertEquals("test4_2014-01-01T00:00:00.000Z_2015-01-01T00:00:00.000Z_version4",
row3[1].toString());
+ Assertions.assertEquals("server2:1234", row3[0]);
+
Assertions.assertEquals("test4_2014-01-01T00:00:00.000Z_2015-01-01T00:00:00.000Z_version4",
row3[1].toString());
Object[] row4 = rows.get(4);
- Assert.assertEquals("server2:1234", row4[0]);
-
Assert.assertEquals("test5_2015-01-01T00:00:00.000Z_2016-01-01T00:00:00.000Z_version5",
row4[1].toString());
+ Assertions.assertEquals("server2:1234", row4[0]);
+
Assertions.assertEquals("test5_2015-01-01T00:00:00.000Z_2016-01-01T00:00:00.000Z_version5",
row4[1].toString());
// Verify value types.
verifyTypes(rows, SystemSchema.SERVER_SEGMENTS_SIGNATURE);
@@ -1442,36 +1443,36 @@ public class SystemSchemaTest extends CalciteTestBase
final List<Object[]> rows = tasksTable.scan(dataContext).toList();
Object[] row0 = rows.get(0);
- Assert.assertEquals("index_wikipedia_2018-09-20T22:33:44.911Z",
row0[0].toString());
- Assert.assertEquals("group_index_wikipedia_2018-09-20T22:33:44.911Z",
row0[1].toString());
- Assert.assertEquals("index", row0[2].toString());
- Assert.assertEquals("wikipedia", row0[3].toString());
- Assert.assertEquals("2018-09-20T22:33:44.922Z", row0[4].toString());
- Assert.assertEquals("1970-01-01T00:00:00.000Z", row0[5].toString());
- Assert.assertEquals("FAILED", row0[6].toString());
- Assert.assertEquals("NONE", row0[7].toString());
- Assert.assertEquals(-1L, row0[8]);
- Assert.assertEquals("testHost:1234", row0[9]);
- Assert.assertEquals("testHost", row0[10]);
- Assert.assertEquals(1234L, row0[11]);
- Assert.assertEquals(-1L, row0[12]);
- Assert.assertEquals(null, row0[13]);
+ Assertions.assertEquals("index_wikipedia_2018-09-20T22:33:44.911Z",
row0[0].toString());
+ Assertions.assertEquals("group_index_wikipedia_2018-09-20T22:33:44.911Z",
row0[1].toString());
+ Assertions.assertEquals("index", row0[2].toString());
+ Assertions.assertEquals("wikipedia", row0[3].toString());
+ Assertions.assertEquals("2018-09-20T22:33:44.922Z", row0[4].toString());
+ Assertions.assertEquals("1970-01-01T00:00:00.000Z", row0[5].toString());
+ Assertions.assertEquals("FAILED", row0[6].toString());
+ Assertions.assertEquals("NONE", row0[7].toString());
+ Assertions.assertEquals(-1L, row0[8]);
+ Assertions.assertEquals("testHost:1234", row0[9]);
+ Assertions.assertEquals("testHost", row0[10]);
+ Assertions.assertEquals(1234L, row0[11]);
+ Assertions.assertEquals(-1L, row0[12]);
+ Assertions.assertEquals(null, row0[13]);
Object[] row1 = rows.get(1);
- Assert.assertEquals("index_wikipedia_2018-09-21T18:38:47.773Z",
row1[0].toString());
- Assert.assertEquals("group_index_wikipedia_2018-09-21T18:38:47.773Z",
row1[1].toString());
- Assert.assertEquals("index", row1[2].toString());
- Assert.assertEquals("wikipedia", row1[3].toString());
- Assert.assertEquals("2018-09-21T18:38:47.873Z", row1[4].toString());
- Assert.assertEquals("2018-09-21T18:38:47.910Z", row1[5].toString());
- Assert.assertEquals("RUNNING", row1[6].toString());
- Assert.assertEquals("RUNNING", row1[7].toString());
- Assert.assertEquals(0L, row1[8]);
- Assert.assertEquals("192.168.1.6:8100", row1[9]);
- Assert.assertEquals("192.168.1.6", row1[10]);
- Assert.assertEquals(8100L, row1[11]);
- Assert.assertEquals(-1L, row1[12]);
- Assert.assertEquals(null, row1[13]);
+ Assertions.assertEquals("index_wikipedia_2018-09-21T18:38:47.773Z",
row1[0].toString());
+ Assertions.assertEquals("group_index_wikipedia_2018-09-21T18:38:47.773Z",
row1[1].toString());
+ Assertions.assertEquals("index", row1[2].toString());
+ Assertions.assertEquals("wikipedia", row1[3].toString());
+ Assertions.assertEquals("2018-09-21T18:38:47.873Z", row1[4].toString());
+ Assertions.assertEquals("2018-09-21T18:38:47.910Z", row1[5].toString());
+ Assertions.assertEquals("RUNNING", row1[6].toString());
+ Assertions.assertEquals("RUNNING", row1[7].toString());
+ Assertions.assertEquals(0L, row1[8]);
+ Assertions.assertEquals("192.168.1.6:8100", row1[9]);
+ Assertions.assertEquals("192.168.1.6", row1[10]);
+ Assertions.assertEquals(8100L, row1[11]);
+ Assertions.assertEquals(-1L, row1[12]);
+ Assertions.assertEquals(null, row1[13]);
// Verify value types.
verifyTypes(rows, SystemSchema.TASKS_SIGNATURE);
@@ -1530,19 +1531,19 @@ public class SystemSchemaTest extends CalciteTestBase
List<Object[]> rows = tasksTable
.scan(createDataContext(Users.DATASOURCE_WRITE))
.toList();
- Assert.assertTrue(rows.isEmpty());
+ Assertions.assertTrue(rows.isEmpty());
// Verify that 2 rows are returned for Datasource Read user
rows = tasksTable
.scan(createDataContext(Users.DATASOURCE_READ))
.toList();
- Assert.assertEquals(2, rows.size());
+ Assertions.assertEquals(2, rows.size());
// Verify that 2 rows are returned for Super user
rows = tasksTable
.scan(createDataContext(Users.SUPER))
.toList();
- Assert.assertEquals(2, rows.size());
+ Assertions.assertEquals(2, rows.size());
}
@Test
@@ -1580,15 +1581,15 @@ public class SystemSchemaTest extends CalciteTestBase
final List<Object[]> rows = supervisorTable.scan(dataContext).toList();
Object[] row0 = rows.get(0);
- Assert.assertEquals("wikipedia_supervisor", row0[0].toString());
- Assert.assertEquals("wikipedia", row0[1].toString());
- Assert.assertEquals("UNHEALTHY_SUPERVISOR", row0[2].toString());
- Assert.assertEquals("UNABLE_TO_CONNECT_TO_STREAM", row0[3].toString());
- Assert.assertEquals(0L, row0[4]);
- Assert.assertEquals("kafka", row0[5].toString());
- Assert.assertEquals("wikipedia", row0[6].toString());
- Assert.assertEquals(0L, row0[7]);
- Assert.assertEquals(
+ Assertions.assertEquals("wikipedia_supervisor", row0[0].toString());
+ Assertions.assertEquals("wikipedia", row0[1].toString());
+ Assertions.assertEquals("UNHEALTHY_SUPERVISOR", row0[2].toString());
+ Assertions.assertEquals("UNABLE_TO_CONNECT_TO_STREAM", row0[3].toString());
+ Assertions.assertEquals(0L, row0[4]);
+ Assertions.assertEquals("kafka", row0[5].toString());
+ Assertions.assertEquals("wikipedia", row0[6].toString());
+ Assertions.assertEquals(0L, row0[7]);
+ Assertions.assertEquals(
"{\"type\":\"kafka\",\"dataSchema\":{\"dataSource\":\"wikipedia\"},\"context\":null,\"suspended\":false}",
row0[8].toString()
);
@@ -1630,19 +1631,19 @@ public class SystemSchemaTest extends CalciteTestBase
List<Object[]> rows = supervisorTable
.scan(createDataContext(Users.DATASOURCE_WRITE))
.toList();
- Assert.assertTrue(rows.isEmpty());
+ Assertions.assertTrue(rows.isEmpty());
// Verify that 1 row is returned for Datasource Write user
rows = supervisorTable
.scan(createDataContext(Users.DATASOURCE_READ))
.toList();
- Assert.assertEquals(1, rows.size());
+ Assertions.assertEquals(1, rows.size());
// Verify that 1 row is returned for Super user
rows = supervisorTable
.scan(createDataContext(Users.SUPER))
.toList();
- Assert.assertEquals(1, rows.size());
+ Assertions.assertEquals(1, rows.size());
// TODO: If needed, verify the first row here
@@ -1751,9 +1752,9 @@ public class SystemSchemaTest extends CalciteTestBase
final List<Object[]> rows = propertiesTable.scan(dataContext,
Collections.emptyList(), null).toList();
expectedRows.sort((Object[] row1, Object[] row2) -> ((Comparable)
row1[0]).compareTo(row2[0]));
rows.sort((Object[] row1, Object[] row2) -> ((Comparable)
row1[0]).compareTo(row2[0]));
- Assert.assertEquals(expectedRows.size(), rows.size());
+ Assertions.assertEquals(expectedRows.size(), rows.size());
for (int i = 0; i < expectedRows.size(); i++) {
- Assert.assertArrayEquals(expectedRows.get(i), rows.get(i));
+ Assertions.assertArrayEquals(expectedRows.get(i), rows.get(i));
}
}
@@ -1784,20 +1785,20 @@ public class SystemSchemaTest extends CalciteTestBase
final List<Object[]> rows = propertiesTable.scan(dataContext,
Collections.emptyList(), null).toList();
// Should return 1 row even though properties fetch failed
- Assert.assertEquals(1, rows.size());
+ Assertions.assertEquals(1, rows.size());
// Verify server info is present
- Assert.assertEquals(coordinator.getDruidNode().getHostAndPortToUse(),
rows.get(0)[0]);
- Assert.assertEquals(coordinator.getDruidNode().getServiceName(),
rows.get(0)[1]);
+ Assertions.assertEquals(coordinator.getDruidNode().getHostAndPortToUse(),
rows.get(0)[0]);
+ Assertions.assertEquals(coordinator.getDruidNode().getServiceName(),
rows.get(0)[1]);
// Property and value should be null
- Assert.assertNull(rows.get(0)[3]);
- Assert.assertNull(rows.get(0)[4]);
+ Assertions.assertNull(rows.get(0)[3]);
+ Assertions.assertNull(rows.get(0)[4]);
// Error column (index 5) should contain error message
- Assert.assertNotNull(rows.get(0)[5]);
+ Assertions.assertNotNull(rows.get(0)[5]);
String error = (String) rows.get(0)[5];
- Assert.assertTrue("Error should mention connection refused",
error.contains("Connection refused"));
+ Assertions.assertTrue(error.contains("Connection refused"), "Error should
mention connection refused");
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -1831,12 +1832,12 @@ public class SystemSchemaTest extends CalciteTestBase
DataContext dataContext = createDataContext(Users.SUPER);
final List<Object[]> rows = propertiesTable.scan(dataContext,
Collections.emptyList(), null).toList();
- Assert.assertEquals(1, rows.size());
+ Assertions.assertEquals(1, rows.size());
// Error column should contain HTTP status
- Assert.assertNotNull(rows.get(0)[5]);
+ Assertions.assertNotNull(rows.get(0)[5]);
String error = (String) rows.get(0)[5];
- Assert.assertTrue("Error should mention HTTP 503", error.contains("503"));
+ Assertions.assertTrue(error.contains("503"), "Error should mention HTTP
503");
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -1877,10 +1878,10 @@ public class SystemSchemaTest extends CalciteTestBase
DataContext dataContext = createDataContext(Users.SUPER);
final List<Object[]> rows = propertiesTable.scan(dataContext,
ImmutableList.of(serverEquality), null).toList();
- Assert.assertEquals(1, rows.size());
- Assert.assertEquals("localhost:8081", rows.get(0)[0]);
- Assert.assertEquals("druid.key", rows.get(0)[3]);
- Assert.assertEquals("val", rows.get(0)[4]);
+ Assertions.assertEquals(1, rows.size());
+ Assertions.assertEquals("localhost:8081", rows.get(0)[0]);
+ Assertions.assertEquals("druid.key", rows.get(0)[3]);
+ Assertions.assertEquals("val", rows.get(0)[4]);
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -1919,8 +1920,8 @@ public class SystemSchemaTest extends CalciteTestBase
final List<Object[]> rows =
propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(serverIn), null).toList();
- Assert.assertEquals(1, rows.size());
- Assert.assertEquals("localhost:8081", rows.get(0)[0]);
+ Assertions.assertEquals(1, rows.size());
+ Assertions.assertEquals("localhost:8081", rows.get(0)[0]);
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -1972,7 +1973,7 @@ public class SystemSchemaTest extends CalciteTestBase
DataContext dataContext = createDataContext(Users.SUPER);
List<Object[]> rows = propertiesTable.scan(dataContext,
ImmutableList.of(serviceNameEquality), null).toList();
- Assert.assertEquals(2, rows.size());
+ Assertions.assertEquals(2, rows.size());
// Non-matching server filter returns 0 rows with no HTTP calls
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
@@ -1988,7 +1989,7 @@ public class SystemSchemaTest extends CalciteTestBase
dataContext = createDataContext(Users.SUPER);
rows = propertiesTable.scan(dataContext,
ImmutableList.of(nonMatchingFilter), null).toList();
- Assert.assertEquals(0, rows.size());
+ Assertions.assertEquals(0, rows.size());
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -2020,7 +2021,7 @@ public class SystemSchemaTest extends CalciteTestBase
rexBuilder.makeInputRef(rowType.getFieldList().get(SERVER_INDEX).getType(),
SERVER_INDEX),
rexBuilder.makeLiteral("some-server:1234")
);
- Assert.assertEquals(2,
propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(notEquals), null).toList().size());
+ Assertions.assertEquals(2,
propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(notEquals), null).toList().size());
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
// 2) Non-RexCall filter (bare RexInputRef) is ignored
@@ -2034,7 +2035,7 @@ public class SystemSchemaTest extends CalciteTestBase
EasyMock.replay(druidNodeDiscoveryProvider, httpClient);
final RexNode inputRef =
rexBuilder.makeInputRef(rowType.getFieldList().get(SERVER_INDEX).getType(),
SERVER_INDEX);
- Assert.assertEquals(2,
propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(inputRef), null).toList().size());
+ Assertions.assertEquals(2,
propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(inputRef), null).toList().size());
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
// 3) Equality on non-pushed column (property) is ignored
@@ -2052,7 +2053,7 @@ public class SystemSchemaTest extends CalciteTestBase
rexBuilder.makeInputRef(rowType.getFieldList().get(PROPERTY_INDEX).getType(),
PROPERTY_INDEX),
rexBuilder.makeLiteral("druid.key")
);
- Assert.assertEquals(2,
propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(propertyEquality), null).toList().size());
+ Assertions.assertEquals(2,
propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(propertyEquality), null).toList().size());
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
// 4) Reversed equality ('localhost:8081' = server) is correctly extracted
@@ -2071,8 +2072,8 @@ public class SystemSchemaTest extends CalciteTestBase
rexBuilder.makeInputRef(rowType.getFieldList().get(SERVER_INDEX).getType(),
SERVER_INDEX)
);
List<Object[]> rows = propertiesTable.scan(createDataContext(Users.SUPER),
ImmutableList.of(reversedEquality), null).toList();
- Assert.assertEquals(2, rows.size());
- Assert.assertEquals("localhost:8081", rows.get(0)[0]);
+ Assertions.assertEquals(2, rows.size());
+ Assertions.assertEquals("localhost:8081", rows.get(0)[0]);
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -2123,10 +2124,10 @@ public class SystemSchemaTest extends CalciteTestBase
// Multi-role: only 1 HTTP call, node_roles contains both
final List<Object[]> fullRows = propertiesTable.scan(dataContext,
Collections.emptyList(), null).toList();
- Assert.assertEquals(1, fullRows.size());
+ Assertions.assertEquals(1, fullRows.size());
String nodeRoles = (String) fullRows.get(0)[2];
- Assert.assertTrue(nodeRoles.contains("coordinator"));
- Assert.assertTrue(nodeRoles.contains("overlord"));
+ Assertions.assertTrue(nodeRoles.contains("coordinator"));
+ Assertions.assertTrue(nodeRoles.contains("overlord"));
// Projection: project only server (0) and property (3)
EasyMock.reset(druidNodeDiscoveryProvider, httpClient);
@@ -2142,10 +2143,10 @@ public class SystemSchemaTest extends CalciteTestBase
final int[] projects = new int[]{0, 3};
final List<Object[]> projectedRows = propertiesTable.scan(dataContext,
Collections.emptyList(), projects).toList();
- Assert.assertEquals(1, projectedRows.size());
- Assert.assertEquals(2, projectedRows.get(0).length);
- Assert.assertEquals("localhost:8081", projectedRows.get(0)[0]);
- Assert.assertEquals("druid.port", projectedRows.get(0)[1]);
+ Assertions.assertEquals(1, projectedRows.size());
+ Assertions.assertEquals(2, projectedRows.get(0).length);
+ Assertions.assertEquals("localhost:8081", projectedRows.get(0)[0]);
+ Assertions.assertEquals("druid.port", projectedRows.get(0)[1]);
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -2172,12 +2173,12 @@ public class SystemSchemaTest extends CalciteTestBase
DataContext dataContext = createDataContext(Users.SUPER);
Thread.currentThread().interrupt();
- RuntimeException ex = Assert.assertThrows(
+ RuntimeException ex = Assertions.assertThrows(
RuntimeException.class,
() -> propertiesTable.scan(dataContext, Collections.emptyList(),
null).toList()
);
- Assert.assertTrue(ex.getMessage().contains("Interrupted"));
- Assert.assertTrue(Thread.currentThread().isInterrupted());
+ Assertions.assertTrue(ex.getMessage().contains("Interrupted"));
+ Assertions.assertTrue(Thread.currentThread().isInterrupted());
Thread.interrupted();
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
@@ -2205,8 +2206,8 @@ public class SystemSchemaTest extends CalciteTestBase
DataContext dataContext = createDataContext(Users.SUPER);
final List<Object[]> rows = propertiesTable.scan(dataContext,
Collections.emptyList(), null).toList();
- Assert.assertEquals(1, rows.size());
- Assert.assertEquals("RuntimeException", rows.get(0)[5]);
+ Assertions.assertEquals(1, rows.size());
+ Assertions.assertEquals("RuntimeException", rows.get(0)[5]);
EasyMock.verify(druidNodeDiscoveryProvider, httpClient);
}
@@ -2234,19 +2235,19 @@ public class SystemSchemaTest extends CalciteTestBase
final DataContext dataContext = createDataContext(Users.SUPER);
final List<Object[]> rows = queriesTable.scan(dataContext,
Collections.emptyList(), null).toList();
- Assert.assertEquals(2, rows.size());
+ Assertions.assertEquals(2, rows.size());
// Verify first row
- Assert.assertEquals("query-1", rows.get(0)[0]);
- Assert.assertEquals("native", rows.get(0)[1]);
- Assert.assertEquals("RUNNING", rows.get(0)[2]);
- Assert.assertNotNull(rows.get(0)[3]); // info should be serialized JSON
+ Assertions.assertEquals("query-1", rows.get(0)[0]);
+ Assertions.assertEquals("native", rows.get(0)[1]);
+ Assertions.assertEquals("RUNNING", rows.get(0)[2]);
+ Assertions.assertNotNull(rows.get(0)[3]); // info should be serialized JSON
// Verify second row
- Assert.assertEquals("query-2", rows.get(1)[0]);
- Assert.assertEquals("native", rows.get(1)[1]);
- Assert.assertEquals("COMPLETED", rows.get(1)[2]);
- Assert.assertNotNull(rows.get(1)[3]); // info should be serialized JSON
+ Assertions.assertEquals("query-2", rows.get(1)[0]);
+ Assertions.assertEquals("native", rows.get(1)[1]);
+ Assertions.assertEquals("COMPLETED", rows.get(1)[2]);
+ Assertions.assertNotNull(rows.get(1)[3]); // info should be serialized JSON
// Verify value types
verifyTypes(rows, SystemSchema.QUERIES_SIGNATURE);
@@ -2285,7 +2286,7 @@ public class SystemSchemaTest extends CalciteTestBase
List<Object[]> rows = supervisorTable
.scan(createDataContext(Users.ONLY_DATASOURCE_ALL_ACCESS))
.toList();
- Assert.assertEquals(1, rows.size());
+ Assertions.assertEquals(1, rows.size());
EasyMock.verify(overlordClient);
EasyMock.reset(overlordClient);
@@ -2314,7 +2315,7 @@ public class SystemSchemaTest extends CalciteTestBase
rows = supervisorTable
.scan(createDataContext(Users.ONLY_DATASOURCE_ALL_ACCESS))
.toList();
- Assert.assertTrue(rows.isEmpty());
+ Assertions.assertTrue(rows.isEmpty());
EasyMock.verify(overlordClient);
EasyMock.reset(overlordClient);
@@ -2343,7 +2344,7 @@ public class SystemSchemaTest extends CalciteTestBase
rows = supervisorTable
.scan(createDataContext(Users.ONLY_DATASOURCE_ALL_ACCESS))
.toList();
- Assert.assertTrue(rows.isEmpty());
+ Assertions.assertTrue(rows.isEmpty());
EasyMock.verify(overlordClient);
EasyMock.reset(overlordClient);
}
@@ -2465,7 +2466,7 @@ public class SystemSchemaTest extends CalciteTestBase
final RelDataType rowType = RowSignatures.toRelDataType(signature, new
JavaTypeFactoryImpl());
for (Object[] row : rows) {
- Assert.assertEquals(row.length, signature.size());
+ Assertions.assertEquals(row.length, signature.size());
for (int i = 0; i < row.length; i++) {
final Class<?> expectedClass;
@@ -2494,24 +2495,24 @@ public class SystemSchemaTest extends CalciteTestBase
}
if (nullable) {
- Assert.assertTrue(
+ Assertions.assertTrue(
+ row[i] == null ||
expectedClass.isAssignableFrom(row[i].getClass()),
StringUtils.format(
"Column[%s] is a [%s] or null (was %s)",
signature.getColumnName(i),
expectedClass.getName(),
row[i] == null ? null : row[i].getClass().getName()
- ),
- row[i] == null ||
expectedClass.isAssignableFrom(row[i].getClass())
+ )
);
} else {
- Assert.assertTrue(
+ Assertions.assertTrue(
+ row[i] != null &&
expectedClass.isAssignableFrom(row[i].getClass()),
StringUtils.format(
"Column[%s] is a [%s] (was %s)",
signature.getColumnName(i),
expectedClass.getName(),
row[i] == null ? null : row[i].getClass().getName()
- ),
- row[i] != null &&
expectedClass.isAssignableFrom(row[i].getClass())
+ )
);
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
