diff --git a/quidem-ut/pom.xml b/quidem-ut/pom.xml index b936d54169a2..82c2352d0c8e 100644 --- a/quidem-ut/pom.xml +++ b/quidem-ut/pom.xml @@ -449,19 +449,10 @@ org.junit.jupiter junit-jupiter - - org.junit.vintage - junit-vintage-engine - test - org.junit.jupiter junit-jupiter-api - - junit - junit - org.apache.calcite.avatica avatica @@ -494,12 +485,12 @@ org.hamcrest hamcrest - compile + test org.hamcrest hamcrest-core - compile + test org.mockito diff --git a/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java b/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java index 6402cd63e433..5e726da11824 100644 --- a/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java +++ b/quidem-ut/src/test/java/org/apache/druid/quidem/LauncherSmokeTest.java @@ -26,26 +26,25 @@ import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.apache.http.util.EntityUtils; -import org.hamcrest.MatcherAssert; -import org.hamcrest.Matchers; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; public class LauncherSmokeTest { private static Launcher launcher; - @BeforeClass + @BeforeAll public static void setUp() throws Exception { launcher = new Launcher("druidtest:///"); launcher.start(); } - @AfterClass + @AfterAll public static void tearDown() { launcher.shutdown(); @@ -71,6 +70,6 @@ public void chkStatusWorks() throws Exception CloseableHttpResponse response = client.execute(request); assertEquals(200, response.getStatusLine().getStatusCode()); String responseStr = EntityUtils.toString(response.getEntity()); - MatcherAssert.assertThat(responseStr, Matchers.containsString("\"version\":\"")); + Assertions.assertTrue(responseStr.contains("\"version\":\"")); } } diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java index 3f039814c0f5..2593f3d579eb 100644 --- a/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java +++ b/sql/src/test/java/org/apache/druid/quidem/DruidAvaticaDriverTest.java @@ -28,9 +28,9 @@ import java.sql.SQLException; import java.sql.Statement; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class DruidAvaticaDriverTest { diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java index af52f4feb57e..ad09ff1fb4f3 100644 --- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java +++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemCommandHandler.java @@ -52,7 +52,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import static org.junit.Assume.assumeFalse; +import static org.junit.jupiter.api.Assumptions.assumeFalse; public class DruidQuidemCommandHandler implements CommandHandler { @@ -357,7 +357,7 @@ public final void execute(Context context, boolean execute) try { Injector injector = DruidConnectionExtras.unwrapOrThrow(context.connection()).getInjector(); SqlTestFrameworkConfig cfg = injector.getInstance(SqlTestFrameworkConfig.class); - assumeFalse(message, cfg.componentSupplier.getSimpleName().equals(supplierName)); + assumeFalse(cfg.componentSupplier.getSimpleName().equals(supplierName), message); } catch (Exception e) { // This is packaged as an Error because Quidem grabs anything else and pushes it into the output file diff --git a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java index 4f5e03885aa2..7da83f33180d 100644 --- a/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java +++ b/sql/src/test/java/org/apache/druid/quidem/DruidQuidemTestBase.java @@ -40,11 +40,11 @@ import org.apache.druid.sql.calcite.MultiComponentSupplier; import org.apache.druid.sql.calcite.SqlTestFrameworkConfig; import org.apache.druid.sql.calcite.util.SqlTestFramework.QueryComponentSupplier; -import org.junit.AssumptionViolatedException; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.TestInstance; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import org.opentest4j.TestAbortedException; import java.io.File; import java.io.FileNotFoundException; @@ -323,10 +323,10 @@ public void test(QuidemTestCaseConfiguration testConfig) throws Exception druidQuidemRunner.run(inFile, outFile, testConfig.componentSupplierName); } catch (Error e) { - // This catch is needed to workaround the way Quidem currently handles AssumptionViolatedException + // This catch is needed to workaround the way Quidem currently handles TestAbortedException Throwable cause = e.getCause(); - if (cause != null && cause instanceof AssumptionViolatedException) { - AssumptionViolatedException assumptionViolatedException = (AssumptionViolatedException) cause; + if (cause != null && cause instanceof TestAbortedException) { + TestAbortedException assumptionViolatedException = (TestAbortedException) cause; throw assumptionViolatedException; } throw e; diff --git a/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java b/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java index 74d5439fcec4..59b8c77860f9 100644 --- a/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java +++ b/sql/src/test/java/org/apache/druid/sql/SqlLifecycleManagerTest.java @@ -22,9 +22,9 @@ import com.google.common.collect.ImmutableList; import org.apache.druid.server.security.ResourceAction; import org.apache.druid.sql.SqlLifecycleManager.Cancelable; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.util.Collections; import java.util.List; @@ -34,7 +34,7 @@ public class SqlLifecycleManagerTest { private SqlLifecycleManager lifecycleManager; - @Before + @BeforeEach public void setup() { lifecycleManager = new SqlLifecycleManager(); @@ -46,7 +46,7 @@ public void testAddAuthorizedLifecycle() final String sqlId = "sqlId"; Cancelable lifecycle = mockLifecycle(); lifecycleManager.add(sqlId, lifecycle); - Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); } @Test @@ -55,9 +55,9 @@ public void testRemoveValidLifecycle() final String sqlId = "sqlId"; Cancelable lifecycle = mockLifecycle(); lifecycleManager.add(sqlId, lifecycle); - Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); lifecycleManager.remove(sqlId, lifecycle); - Assert.assertEquals(ImmutableList.of(), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(), lifecycleManager.getAll(sqlId)); } @Test @@ -66,9 +66,9 @@ public void testRemoveInvalidSqlQueryId() final String sqlId = "sqlId"; Cancelable lifecycle = mockLifecycle(); lifecycleManager.add(sqlId, lifecycle); - Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); lifecycleManager.remove("invalid", lifecycle); - Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); } @Test @@ -77,9 +77,9 @@ public void testRemoveValidSqlQueryIdDifferntLifecycleObject() final String sqlId = "sqlId"; Cancelable lifecycle = mockLifecycle(); lifecycleManager.add(sqlId, lifecycle); - Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); lifecycleManager.remove(sqlId, mockLifecycle()); - Assert.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(lifecycle), lifecycleManager.getAll(sqlId)); } @Test @@ -92,9 +92,9 @@ public void testRemoveAllValidSqlQueryIdSubsetOfLifecycles() mockLifecycle() ); lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle)); - Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId)); lifecycleManager.removeAll(sqlId, ImmutableList.of(lifecycles.get(0), lifecycles.get(1))); - Assert.assertEquals(ImmutableList.of(lifecycles.get(2)), lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(ImmutableList.of(lifecycles.get(2)), lifecycleManager.getAll(sqlId)); } @Test @@ -107,9 +107,9 @@ public void testRemoveAllInvalidSqlQueryId() mockLifecycle() ); lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle)); - Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId)); lifecycleManager.removeAll("invalid", ImmutableList.of(lifecycles.get(0), lifecycles.get(1))); - Assert.assertEquals(lifecycles, lifecycleManager.getAll(sqlId)); + Assertions.assertEquals(lifecycles, lifecycleManager.getAll(sqlId)); } @Test @@ -124,8 +124,8 @@ public void testGetAllReturnsListCopy() lifecycles.forEach(lifecycle -> lifecycleManager.add(sqlId, lifecycle)); final List lifecyclesFromGetAll = lifecycleManager.getAll(sqlId); lifecycleManager.removeAll(sqlId, lifecyclesFromGetAll); - Assert.assertEquals(lifecycles, lifecyclesFromGetAll); - Assert.assertTrue(lifecycleManager.getAll(sqlId).isEmpty()); + Assertions.assertEquals(lifecycles, lifecyclesFromGetAll); + Assertions.assertTrue(lifecycleManager.getAll(sqlId).isEmpty()); } private static Cancelable mockLifecycle() diff --git a/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java b/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java index 1c793b9ef559..252460f65fe8 100644 --- a/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java +++ b/sql/src/test/java/org/apache/druid/sql/SqlQueryPlusTest.java @@ -23,8 +23,8 @@ import org.apache.druid.error.DruidExceptionMatcher; import org.apache.druid.sql.calcite.util.CalciteTests; import org.hamcrest.MatcherAssert; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.Map; @@ -34,7 +34,7 @@ public class SqlQueryPlusTest public void testSyntaxError() { // SqlQueryPlus throws parse errors on build() if the statement is invalid - final DruidException e = Assert.assertThrows( + final DruidException e = Assertions.assertThrows( DruidException.class, () -> SqlQueryPlus.builder("SELECT COUNT(*) AS cnt, 'foo' AS") .auth(CalciteTests.REGULAR_USER_AUTH_RESULT) @@ -59,7 +59,7 @@ public void testSyntaxErrorJdbc() .buildJdbc(); // It does throw exceptions on freshCopy(), though. - final DruidException e = Assert.assertThrows( + final DruidException e = Assertions.assertThrows( DruidException.class, sqlQueryPlus::freshCopy ); @@ -83,24 +83,24 @@ public void testUserProvidedContextOverridesSystemDefault() .queryContext(userProvidedContext) .auth(CalciteTests.REGULAR_USER_AUTH_RESULT); - Assert.assertEquals( + Assertions.assertEquals( Map.of("key", "user-provided-value", "key2", "system-default2"), sqlQueryPlusBuilder.build().context() ); - Assert.assertEquals( + Assertions.assertEquals( Map.of("key", "user-provided-value", "key2", "system-default2"), sqlQueryPlusBuilder.buildJdbc().context() ); - Assert.assertEquals( + Assertions.assertEquals( Map.of("key", "user-provided-value", "key2", "system-default2"), sqlQueryPlusBuilder.build().withContext(systemDefaultContext, userProvidedContext).context() ); - Assert.assertEquals( + Assertions.assertEquals( Map.of("key", "system-default", "key2", "system-default2"), sqlQueryPlusBuilder.build().withContext(systemDefaultContext, Map.of()).context() ); - Assert.assertEquals( + Assertions.assertEquals( Map.of("key", "user-provided-value"), sqlQueryPlusBuilder.build().withContext(Map.of(), userProvidedContext).context() ); diff --git a/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java b/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java index 5286df34d6b7..bb0244636659 100644 --- a/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java +++ b/sql/src/test/java/org/apache/druid/sql/SqlRowTransformerTest.java @@ -32,7 +32,7 @@ import org.joda.time.DateTime; import org.joda.time.DateTimeZone; import org.joda.time.format.ISODateTimeFormat; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -84,7 +84,7 @@ public void testTransformUTC() expectedRow[2], null }; - Assert.assertArrayEquals( + Assertions.assertArrayEquals( expectedRow, IntStream.range(0, expectedRow.length).mapToObj(i -> transformer.transform(row, i)).toArray() ); @@ -112,7 +112,7 @@ public void testTransformNonUTC() expectedRow[2], null }; - Assert.assertArrayEquals( + Assertions.assertArrayEquals( expectedRow, IntStream.range(0, expectedRow.length).mapToObj(i -> transformer.transform(row, i)).toArray() ); @@ -126,7 +126,7 @@ public void testGetFieldList() rowType ); - Assert.assertEquals( + Assertions.assertEquals( rowType.getFieldList().stream().map(RelDataTypeField::getName).collect(Collectors.toList()), transformer.getFieldList() ); diff --git a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java index 8856a19331f3..0f39507d0ab6 100644 --- a/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java +++ b/sql/src/test/java/org/apache/druid/sql/SqlStatementTest.java @@ -62,19 +62,21 @@ import org.apache.druid.sql.calcite.planner.PrepareResult; import org.apache.druid.sql.calcite.schema.DruidSchemaCatalog; import org.apache.druid.sql.calcite.util.CalciteTests; +import org.apache.druid.sql.calcite.util.SqlTestQueryStack; import org.apache.druid.sql.hook.DruidHookDispatcher; import org.easymock.EasyMock; import org.hamcrest.MatcherAssert; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; import javax.servlet.http.HttpServletRequest; + +import java.io.File; import java.io.IOException; import java.util.Collections; import java.util.List; @@ -82,19 +84,19 @@ import java.util.concurrent.TimeUnit; import static org.apache.druid.sql.calcite.BaseCalciteQueryTest.assertResultsEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; public class SqlStatementTest { private static QueryRunnerFactoryConglomerate conglomerate; private static SpecificSegmentsQuerySegmentWalker walker; private static Closer resourceCloser; - @ClassRule - public static TemporaryFolder temporaryFolder = new TemporaryFolder(); + @TempDir + public static File temporaryFolder; private ListeningExecutorService executorService; private final DefaultQueryConfig defaultQueryConfig = new DefaultQueryConfig( ImmutableMap.of("DEFAULT_KEY", "DEFAULT_VALUE")); @@ -102,11 +104,11 @@ public class SqlStatementTest private PolicyEnforcer policyEnforcer; private SqlStatementFactory sqlStatementFactory; - @BeforeClass - public static void setUpClass() throws Exception + @BeforeAll + public static void setUpClass() { resourceCloser = Closer.create(); - conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(resourceCloser); + conglomerate = SqlTestQueryStack.createQueryRunnerFactoryConglomerate(resourceCloser); final QueryScheduler scheduler = new QueryScheduler( 5, @@ -125,17 +127,17 @@ public Sequence run(Query query, Sequence resultSequence) } }; - walker = CalciteTests.createMockWalker(conglomerate, temporaryFolder.newFolder(), scheduler); + walker = CalciteTests.createMockWalker(conglomerate, temporaryFolder, scheduler); resourceCloser.register(walker); } - @AfterClass + @AfterAll public static void tearDownClass() throws IOException { resourceCloser.close(); } - @Before + @BeforeEach public void setUp() { executorService = MoreExecutors.listeningDecorator(Execs.multiThreaded(8, "test_sql_resource_%s")); @@ -144,7 +146,7 @@ public void setUp() this.sqlStatementFactory = buildSqlStatementFactory(); } - @After + @AfterEach public void tearDown() throws Exception { executorService.shutdownNow(); @@ -254,11 +256,11 @@ public void testDirectPolicyEnforcerThrowsForNoPolicy() ); DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq); ResultSet resultSet = stmt.plan(); - DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run()); + DruidException e = Assertions.assertThrows(DruidException.class, () -> resultSet.run()); - Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory()); - Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona()); - Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage()); + Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory()); + Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona()); + Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage()); } @Test @@ -390,11 +392,11 @@ public void testHttpPolicyEnforcerThrowsForNoPolicy() throws Exception request(true) ); ResultSet resultSet = stmt.plan(); - DruidException e = Assert.assertThrows(DruidException.class, () -> resultSet.run()); + DruidException e = Assertions.assertThrows(DruidException.class, () -> resultSet.run()); - Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory()); - Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona()); - Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage()); + Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory()); + Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona()); + Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage()); } @Test @@ -495,11 +497,11 @@ public void testPreparePolicyEnforcerThrowsForNoPolicy() CalciteTests.REGULAR_USER_AUTH_RESULT ); PreparedStatement stmt = sqlStatementFactory.preparedStatement(sqlReq); - DruidException e = Assert.assertThrows(DruidException.class, () -> stmt.execute(Collections.emptyList(), null).execute()); + DruidException e = Assertions.assertThrows(DruidException.class, () -> stmt.execute(Collections.emptyList(), null).execute()); - Assert.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory()); - Assert.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona()); - Assert.assertEquals("Failed security validation with dataSource [foo]", e.getMessage()); + Assertions.assertEquals(DruidException.Category.FORBIDDEN, e.getCategory()); + Assertions.assertEquals(DruidException.Persona.OPERATOR, e.getTargetPersona()); + Assertions.assertEquals("Failed security validation with dataSource [foo]", e.getMessage()); } @Test @@ -532,7 +534,7 @@ public void testIgnoredQueryContextParametersAreIgnored() DirectStatement stmt = sqlStatementFactory.directStatement(sqlReq); Map context = stmt.context(); // should contain only query id, not bySegment since it is not valid for SQL - Assert.assertEquals(Collections.singleton(QueryContexts.CTX_SQL_QUERY_ID), context.keySet()); + Assertions.assertEquals(Collections.singleton(QueryContexts.CTX_SQL_QUERY_ID), context.keySet()); } private SqlStatementFactory buildSqlStatementFactory() diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java index 1918736af32f..ec1554c3f25e 100644 --- a/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/avatica/AvaticaModuleTest.java @@ -32,22 +32,21 @@ import org.apache.druid.java.util.metrics.Monitor; import org.apache.druid.server.DruidNode; import org.easymock.EasyMock; -import org.easymock.EasyMockRunner; +import org.easymock.EasyMockExtension; import org.easymock.Mock; import org.eclipse.jetty.server.Handler; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.ExpectedException; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import javax.validation.Validation; import javax.validation.Validator; + import java.util.Properties; import java.util.Set; -@RunWith(EasyMockRunner.class) +@ExtendWith(EasyMockExtension.class) public class AvaticaModuleTest { private static final String HOST_AND_PORT = "HOST_AND_PORT"; @@ -57,13 +56,10 @@ public class AvaticaModuleTest @Mock private DruidMeta druidMeta; - @Rule - public ExpectedException expectedException = ExpectedException.none(); - private AvaticaModule target; private Injector injector; - @Before + @BeforeEach public void setUp() { EasyMock.expect(druidNode.getHostAndPortToUse()).andStubReturn(HOST_AND_PORT); @@ -85,9 +81,9 @@ public void setUp() public void testAvaticaMonitorIsInjectedAsSingleton() { AvaticaMonitor monitor = injector.getInstance(AvaticaMonitor.class); - Assert.assertNotNull(monitor); + Assertions.assertNotNull(monitor); AvaticaMonitor other = injector.getInstance(AvaticaMonitor.class); - Assert.assertSame(monitor, other); + Assertions.assertSame(monitor, other); } @Test @@ -95,22 +91,22 @@ public void testAvaticaMonitorIsRegisterdWithMetricsModule() { Set> monitors = injector.getInstance(Key.get(new TypeLiteral<>() {})); - Assert.assertTrue(monitors.contains(AvaticaMonitor.class)); + Assertions.assertTrue(monitors.contains(AvaticaMonitor.class)); } @Test public void testAvaticaServerConfigIsInjectable() { AvaticaServerConfig config = injector.getInstance(AvaticaServerConfig.class); - Assert.assertNotNull(config); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections()); - Assert.assertEquals( + Assertions.assertNotNull(config); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections()); + Assertions.assertEquals( AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION, config.getMaxStatementsPerConnection() ); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout()); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_MIN_ROWS_PER_FRAME, config.getMinRowsPerFrame()); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_ROWS_PER_FRAME, config.getMaxRowsPerFrame()); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout()); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MIN_ROWS_PER_FRAME, config.getMinRowsPerFrame()); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_ROWS_PER_FRAME, config.getMaxRowsPerFrame()); } @Test @@ -125,15 +121,15 @@ public void testAvaticaServerConfigProperties() properties.setProperty("druid.sql.avatica.minRowsPerFrame", "10000"); provider.inject(properties, injector.getInstance(JsonConfigurator.class)); final AvaticaServerConfig config = provider.get(); - Assert.assertNotNull(config); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections()); - Assert.assertEquals( + Assertions.assertNotNull(config); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections()); + Assertions.assertEquals( AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION, config.getMaxStatementsPerConnection() ); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout()); - Assert.assertEquals(10_000, config.getMinRowsPerFrame()); - Assert.assertEquals(50_000, config.getMaxRowsPerFrame()); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout()); + Assertions.assertEquals(10_000, config.getMinRowsPerFrame()); + Assertions.assertEquals(50_000, config.getMaxRowsPerFrame()); } @Test @@ -147,22 +143,20 @@ public void testAvaticaServerConfigPropertiesSmallerMaxIsAlsoMin() properties.setProperty("druid.sql.avatica.maxRowsPerFrame", "50"); provider.inject(properties, injector.getInstance(JsonConfigurator.class)); final AvaticaServerConfig config = provider.get(); - Assert.assertNotNull(config); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections()); - Assert.assertEquals( + Assertions.assertNotNull(config); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_MAX_CONNECTIONS, config.getMaxConnections()); + Assertions.assertEquals( AvaticaServerConfig.DEFAULT_MAX_STATEMENTS_PER_CONNECTION, config.getMaxStatementsPerConnection() ); - Assert.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout()); - Assert.assertEquals(50, config.getMinRowsPerFrame()); - Assert.assertEquals(50, config.getMaxRowsPerFrame()); + Assertions.assertEquals(AvaticaServerConfig.DEFAULT_CONNECTION_IDLE_TIMEOUT, config.getConnectionIdleTimeout()); + Assertions.assertEquals(50, config.getMinRowsPerFrame()); + Assertions.assertEquals(50, config.getMaxRowsPerFrame()); } @Test public void testAvaticaServerConfigPropertiesBadMinRowsPerFrame() { - expectedException.expect(IllegalArgumentException.class); - expectedException.expectMessage("'druid.sql.avatica.minRowsPerFrame' must be set to a value greater than 0"); Properties properties = new Properties(); final JsonConfigProvider provider = JsonConfigProvider.of( "druid.sql.avatica", @@ -171,26 +165,32 @@ public void testAvaticaServerConfigPropertiesBadMinRowsPerFrame() properties.setProperty("druid.sql.avatica.minRowsPerFrame", "-1"); provider.inject(properties, injector.getInstance(JsonConfigurator.class)); final AvaticaServerConfig config = provider.get(); - Assert.assertNotNull(config); - config.getMinRowsPerFrame(); + Assertions.assertNotNull(config); + final IllegalArgumentException e = Assertions.assertThrows( + IllegalArgumentException.class, + config::getMinRowsPerFrame + ); + Assertions.assertTrue( + e.getMessage().contains("'druid.sql.avatica.minRowsPerFrame' must be set to a value greater than 0") + ); } @Test public void testDruidAvaticaJsonHandlerIsInjected() { DruidAvaticaJsonHandler handler = injector.getInstance(DruidAvaticaJsonHandler.class); - Assert.assertNotNull(handler); + Assertions.assertNotNull(handler); DruidAvaticaJsonHandler other = injector.getInstance(DruidAvaticaJsonHandler.class); - Assert.assertNotSame(handler, other); + Assertions.assertNotSame(handler, other); } @Test public void testDruidAvaticaProtobufHandlerIsInjected() { DruidAvaticaProtobufHandler handler = injector.getInstance(DruidAvaticaProtobufHandler.class); - Assert.assertNotNull(handler); + Assertions.assertNotNull(handler); DruidAvaticaProtobufHandler other = injector.getInstance(DruidAvaticaProtobufHandler.class); - Assert.assertNotSame(handler, other); + Assertions.assertNotSame(handler, other); } @Test @@ -198,13 +198,13 @@ public void testDruidAvaticaJsonHandlerIsRegisterdWithJerseyModule() { Set handlers = injector.getInstance(Key.get(new TypeLiteral<>() {})); - Assert.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaJsonHandler.class.equals(h.getClass()))); + Assertions.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaJsonHandler.class.equals(h.getClass()))); } @Test public void testDruidAvaticaProtobufHandlerIsRegisterdWithJerseyModule() { Set handlers = injector.getInstance(Key.get(new TypeLiteral<>() {})); - Assert.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaProtobufHandler.class.equals(h.getClass()))); + Assertions.assertTrue(handlers.stream().anyMatch(h -> DruidAvaticaProtobufHandler.class.equals(h.getClass()))); } } diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java index 416f04624c13..6278d00ca88e 100644 --- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java +++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidAvaticaHandlerTest.java @@ -65,7 +65,6 @@ import org.apache.druid.server.QueryLifecycleFactory; import org.apache.druid.server.QueryScheduler; import org.apache.druid.server.QuerySchedulerProvider; -import org.apache.druid.server.QueryStackTests; import org.apache.druid.server.RequestLogLine; import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker; import org.apache.druid.server.initialization.ServerConfig; @@ -93,15 +92,16 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase; import org.apache.druid.sql.calcite.util.CalciteTests; import org.apache.druid.sql.calcite.util.QueryFrameworkUtils; +import org.apache.druid.sql.calcite.util.SqlTestQueryStack; import org.apache.druid.sql.calcite.util.datasets.TestDataSet; import org.apache.druid.sql.guice.SqlModule; import org.apache.druid.sql.hook.DruidHookDispatcher; import org.eclipse.jetty.server.Server; import org.joda.time.DateTime; import org.joda.time.DateTimeZone; -import org.junit.Assert; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -173,7 +173,7 @@ public class DruidAvaticaHandlerTest extends CalciteTestBase public static void setUpClass(@TempDir File tempDir) { resourceCloser = Closer.create(); - conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(resourceCloser); + conglomerate = SqlTestQueryStack.createQueryRunnerFactoryConglomerate(resourceCloser); walker = CalciteTests.createMockWalker(conglomerate, tempDir); resourceCloser.register(walker); } @@ -361,7 +361,7 @@ public void testSelectCount() throws SQLException try (Statement stmt = client.createStatement()) { final ResultSet resultSet = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo;"); final List> rows = getRows(resultSet); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 6L) ), @@ -377,10 +377,10 @@ public void testForbiddenContextKey() throws SQLException propertiesSetForbiddenKey.setProperty("user", "regularUserLA"); propertiesSetForbiddenKey.setProperty("forbidden-key", "val"); try (Statement stmt = DriverManager.getConnection(server.url, propertiesSetForbiddenKey).createStatement()) { - AvaticaSqlException e = Assert.assertThrows(AvaticaSqlException.class, () -> { + AvaticaSqlException e = Assertions.assertThrows(AvaticaSqlException.class, () -> { stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo"); }); - Assert.assertTrue(e.getMessage().contains("Remote driver error: Unauthorized")); + Assertions.assertTrue(e.getMessage().contains("Remote driver error: Unauthorized")); } } @@ -390,7 +390,7 @@ public void testSelectCountNoTrailingSlash() throws SQLException try (Statement stmt = clientNoTrailingSlash.createStatement()) { final ResultSet resultSet = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo"); final List> rows = getRows(resultSet); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 6L) ), @@ -405,7 +405,7 @@ public void testSelectCountAlternateStyle() throws SQLException try (PreparedStatement stmt = client.prepareStatement("SELECT COUNT(*) AS cnt FROM druid.foo")) { final ResultSet resultSet = stmt.executeQuery(); final List> rows = getRows(resultSet); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 6L) ), @@ -422,7 +422,7 @@ public void testTimestampsInResponse() throws SQLException "SELECT __time, CAST(__time AS DATE) AS t2 FROM druid.foo LIMIT 1" ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of( "__time", new Timestamp(DateTimes.of("2000-01-01T00:00:00.000Z").getMillis()), @@ -447,7 +447,7 @@ public void testTimestampsInResponseLosAngelesTimeZone() throws SQLException final List> resultRows = getRows(resultSet); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of( "__time", new Timestamp(Calcites.jodaToCalciteTimestamp(localDateTime, timeZone)), @@ -467,7 +467,7 @@ public void testFieldAliasingSelect() throws SQLException "SELECT dim2 AS \"x\", dim2 AS \"y\" FROM druid.foo LIMIT 1" ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("x", "a", "y", "a") ), @@ -484,7 +484,7 @@ public void testSelectBoolean() throws SQLException "SELECT dim2, dim2 IS NULL AS isnull FROM druid.foo LIMIT 1" ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("dim2", "a", "isnull", false) ), @@ -501,7 +501,7 @@ public void testExplainSelectCount() throws SQLException "EXPLAIN PLAN FOR SELECT COUNT(*) AS cnt FROM druid.foo" ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of( "PLAN", @@ -524,7 +524,7 @@ public void testExplainSelectCount() throws SQLException public void testDatabaseMetaDataCatalogs() throws SQLException { final DatabaseMetaData metaData = client.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row(Pair.of("TABLE_CAT", "druid")) ), @@ -536,7 +536,7 @@ public void testDatabaseMetaDataCatalogs() throws SQLException public void testDatabaseMetaDataSchemas() throws SQLException { final DatabaseMetaData metaData = client.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row(Pair.of("TABLE_CATALOG", "druid"), Pair.of("TABLE_SCHEM", "druid")) ), @@ -548,7 +548,7 @@ public void testDatabaseMetaDataSchemas() throws SQLException public void testDatabaseMetaDataTables() throws SQLException { final DatabaseMetaData metaData = client.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_CAT", "druid"), @@ -653,7 +653,7 @@ public void testDatabaseMetaDataTables() throws SQLException public void testDatabaseMetaDataTablesAsSuperuser() throws SQLException { final DatabaseMetaData metaData = superuserClient.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_CAT", "druid"), @@ -763,7 +763,7 @@ public void testDatabaseMetaDataTablesAsSuperuser() throws SQLException public void testDatabaseMetaDataColumns() throws SQLException { final DatabaseMetaData metaData = client.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_SCHEM", "druid"), @@ -841,7 +841,7 @@ public void testDatabaseMetaDataColumns() throws SQLException public void testDatabaseMetaDataColumnsOnForbiddenDatasource() throws SQLException { final DatabaseMetaData metaData = client.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of(), getRows( metaData.getColumns(null, "dr_id", CalciteTests.FORBIDDEN_DATASOURCE, null), @@ -854,7 +854,7 @@ public void testDatabaseMetaDataColumnsOnForbiddenDatasource() throws SQLExcepti public void testDatabaseMetaDataColumnsWithSuperuser() throws SQLException { final DatabaseMetaData metaData = superuserClient.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_SCHEM", "druid"), @@ -956,7 +956,7 @@ public void testConcurrentQueries() throw new RE(e); } for (int i = 0; i < 2000; i++) { - Assert.assertEquals(i + 6, (int) integers.get(i)); + Assertions.assertEquals(i + 6, (int) integers.get(i)); } exec.shutdown(); } @@ -970,11 +970,11 @@ public void testTooManyStatements() throws SQLException client.createStatement(); } - AvaticaClientRuntimeException ex = Assert.assertThrows( + AvaticaClientRuntimeException ex = Assertions.assertThrows( AvaticaClientRuntimeException.class, () -> client.createStatement() ); - Assert.assertTrue(ex.getMessage().contains("Too many open statements, limit is 4")); + Assertions.assertTrue(ex.getMessage().contains("Too many open statements, limit is 4")); } @Test @@ -1000,7 +1000,7 @@ public void testManyUsesOfTheSameStatement() throws SQLException final ResultSet resultSet = statement.executeQuery( "SELECT COUNT(*) AS cnt FROM druid.foo" ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 6L) ), @@ -1020,14 +1020,14 @@ public void tesErrorsDoNotCloseStatements() throws SQLException try (Statement statement = client.createStatement()) { try { statement.executeQuery("SELECT SUM(nonexistent) FROM druid.foo"); - Assert.fail(); + Assertions.fail(); } catch (Exception e) { // Expected } final ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo"); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of(ImmutableMap.of("cnt", 6L)), getRows(resultSet) ); @@ -1044,7 +1044,7 @@ public void testNotTooManyStatementsWhenClosed() for (int i = 0; i < 50; i++) { try (final Statement statement = client.createStatement()) { statement.executeQuery("SELECT SUM(nonexistent) FROM druid.foo"); - Assert.fail(); + Assertions.fail(); } catch (Exception e) { // Expected @@ -1058,7 +1058,7 @@ public void testAutoReconnectOnNoSuchConnection() throws SQLException for (int i = 0; i < 50; i++) { try (final Statement statement = client.createStatement()) { final ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo"); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of(ImmutableMap.of("cnt", 6L)), getRows(resultSet) ); @@ -1080,11 +1080,11 @@ public void testTooManyConnections() throws SQLException // codeql[java/database-resource-leak] clientNoTrailingSlash.createStatement(); - AvaticaClientRuntimeException ex = Assert.assertThrows( + AvaticaClientRuntimeException ex = Assertions.assertThrows( AvaticaClientRuntimeException.class, () -> server.getUserConnection() ); - Assert.assertTrue(ex.getMessage().contains("Too many connections")); + Assertions.assertTrue(ex.getMessage().contains("Too many connections")); } @Test @@ -1111,7 +1111,7 @@ public void testConnectionsCloseStatements() throws SQLException final ResultSet resultSet = statement.executeQuery( "SELECT COUNT(*) AS cnt FROM druid.foo" ); - Assert.assertTrue(resultSet.next()); + Assertions.assertTrue(resultSet.next()); } } } @@ -1178,8 +1178,8 @@ public Frame fetch( final Statement statement = smallFrameClient.createStatement(); final ResultSet resultSet = statement.executeQuery("SELECT dim1 FROM druid.foo")) { final List> rows = getRows(resultSet); - Assert.assertEquals(2, frames.size()); - Assert.assertEquals( + Assertions.assertEquals(2, frames.size()); + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("dim1", ""), ImmutableMap.of("dim1", "10.1"), @@ -1225,7 +1225,7 @@ public Frame fetch( ) throws NoSuchStatementException, MissingResultsException { // overriding fetch allows us to track how many frames are processed after the first frame, and also fetch size - Assert.assertEquals(config.minRowsPerFrame, fetchMaxRowCount); + Assertions.assertEquals(config.minRowsPerFrame, fetchMaxRowCount); Frame frame = super.fetch(statement, offset, fetchMaxRowCount); frames.add(frame); return frame; @@ -1241,8 +1241,8 @@ public Frame fetch( try (final ResultSet resultSet = statement.executeQuery()) { final List> rows = getRows(resultSet); // expect minimum threshold to be used, which should be enough to do this all in first fetch - Assert.assertEquals(0, frames.size()); - Assert.assertEquals( + Assertions.assertEquals(0, frames.size()); + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("dim1", ""), ImmutableMap.of("dim1", "10.1"), @@ -1270,48 +1270,48 @@ public void testSqlRequestLog() throws SQLException stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo"); } } - Assert.assertEquals(3, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(3, testRequestLogger.getSqlQueryLogs().size()); for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) { final Map stats = logLine.getQueryStats().getStats(); - Assert.assertEquals(true, stats.get("success")); - Assert.assertEquals("regularUser", stats.get("identity")); - Assert.assertTrue(stats.containsKey("sqlQuery/time")); - Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs")); - Assert.assertTrue(stats.containsKey("sqlQuery/bytes")); + Assertions.assertEquals(true, stats.get("success")); + Assertions.assertEquals("regularUser", stats.get("identity")); + Assertions.assertTrue(stats.containsKey("sqlQuery/time")); + Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs")); + Assertions.assertTrue(stats.containsKey("sqlQuery/bytes")); } // invalid sql testRequestLogger.clear(); try (Statement stmt = client.createStatement()) { stmt.executeQuery("SELECT notexist FROM druid.foo"); - Assert.fail("invalid SQL should throw SQLException"); + Assertions.fail("invalid SQL should throw SQLException"); } catch (SQLException e) { // Expected } - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); { final Map stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats(); - Assert.assertEquals(false, stats.get("success")); - Assert.assertEquals("regularUser", stats.get("identity")); - Assert.assertTrue(stats.containsKey("exception")); + Assertions.assertEquals(false, stats.get("success")); + Assertions.assertEquals("regularUser", stats.get("identity")); + Assertions.assertTrue(stats.containsKey("exception")); } // unauthorized sql testRequestLogger.clear(); try (Statement stmt = client.createStatement()) { stmt.executeQuery("SELECT count(*) FROM druid.forbiddenDatasource"); - Assert.fail("unauthorzed SQL should throw SQLException"); + Assertions.fail("unauthorzed SQL should throw SQLException"); } catch (SQLException e) { // Expected } - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); { final Map stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats(); - Assert.assertEquals(false, stats.get("success")); - Assert.assertEquals("regularUser", stats.get("identity")); - Assert.assertTrue(stats.containsKey("exception")); + Assertions.assertEquals(false, stats.get("success")); + Assertions.assertEquals("regularUser", stats.get("identity")); + Assertions.assertTrue(stats.containsKey("exception")); } } @@ -1325,46 +1325,46 @@ public void testSqlRequestLogPrepared() throws SQLException stmt.execute(); } } - Assert.assertEquals(6, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(6, testRequestLogger.getSqlQueryLogs().size()); for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) { final Map stats = logLine.getQueryStats().getStats(); - Assert.assertEquals(true, stats.get("success")); - Assert.assertEquals("regularUser", stats.get("identity")); - Assert.assertTrue(stats.containsKey("sqlQuery/time")); - Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs")); - Assert.assertTrue(stats.containsKey("sqlQuery/bytes")); + Assertions.assertEquals(true, stats.get("success")); + Assertions.assertEquals("regularUser", stats.get("identity")); + Assertions.assertTrue(stats.containsKey("sqlQuery/time")); + Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs")); + Assertions.assertTrue(stats.containsKey("sqlQuery/bytes")); } // invalid sql testRequestLogger.clear(); try (PreparedStatement stmt = client.prepareStatement("SELECT notexist FROM druid.foo")) { - Assert.fail("invalid SQL should throw SQLException"); + Assertions.fail("invalid SQL should throw SQLException"); } catch (SQLException e) { // Expected } - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); { final Map stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats(); - Assert.assertEquals(false, stats.get("success")); - Assert.assertEquals("regularUser", stats.get("identity")); - Assert.assertTrue(stats.containsKey("exception")); + Assertions.assertEquals(false, stats.get("success")); + Assertions.assertEquals("regularUser", stats.get("identity")); + Assertions.assertTrue(stats.containsKey("exception")); } // unauthorized sql testRequestLogger.clear(); try (PreparedStatement stmt = client.prepareStatement("SELECT count(*) FROM druid.forbiddenDatasource")) { - Assert.fail("unauthorzed SQL should throw SQLException"); + Assertions.fail("unauthorzed SQL should throw SQLException"); } catch (SQLException e) { // Expected } - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); { final Map stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats(); - Assert.assertEquals(false, stats.get("success")); - Assert.assertEquals("regularUser", stats.get("identity")); - Assert.assertTrue(stats.containsKey("exception")); + Assertions.assertEquals(false, stats.get("success")); + Assertions.assertEquals("regularUser", stats.get("identity")); + Assertions.assertTrue(stats.containsKey("exception")); } } @@ -1378,14 +1378,14 @@ public void testParameterBinding() throws SQLException statement.setString(2, "def"); final ResultSet resultSet = statement.executeQuery(); final List> rows = getRows(resultSet); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 2L) ), rows ); - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); - Assert.assertEquals( + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals( List.of( new ClientSqlParameter(SqlType.VARCHAR.toString(), "abc"), new ClientSqlParameter(SqlType.VARCHAR.toString(), "def") @@ -1402,10 +1402,10 @@ public void testSysTableParameterBindingRegularUser() throws SQLException client.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) { statement.setString(1, "dummy"); - Assert.assertThrows( - "Insufficient permission to view servers", + Assertions.assertThrows( AvaticaSqlException.class, - statement::executeQuery + statement::executeQuery, + "Insufficient permission to view servers" ); } } @@ -1416,7 +1416,7 @@ public void testSysTableParameterBindingSuperUser() throws SQLException try (PreparedStatement statement = superuserClient.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) { statement.setString(1, "dummy"); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 1L) ), @@ -1431,19 +1431,19 @@ public void testExecuteMany() throws SQLException try (PreparedStatement statement = superuserClient.prepareStatement("SELECT COUNT(*) AS cnt FROM sys.servers WHERE servers.host = ?")) { statement.setString(1, "dummy"); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 1L) ), getRows(statement.executeQuery()) ); statement.setString(1, "foo"); - Assert.assertEquals( + Assertions.assertEquals( Collections.emptyList(), getRows(statement.executeQuery()) ); statement.setString(1, "dummy"); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 1L) ), @@ -1460,7 +1460,7 @@ public void testExtendedCharacters() throws SQLException "SELECT COUNT(*) AS cnt FROM druid.lotsocolumns WHERE dimMultivalEnumerated = 'ㅑ ㅓ ㅕ ㅗ ㅛ ㅜ ㅠ ㅡ ㅣ'" ); final List> rows = getRows(resultSet); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 1L) ), @@ -1473,7 +1473,7 @@ public void testExtendedCharacters() throws SQLException statement.setString(1, "ㅑ ㅓ ㅕ ㅗ ㅛ ㅜ ㅠ ㅡ ㅣ"); final ResultSet resultSet2 = statement.executeQuery(); final List> rows = getRows(resultSet2); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 1L) ), @@ -1531,7 +1531,7 @@ public void testEscapingForGetColumns() throws SQLException ); // If the escape clause wasn't correctly set, rows for potentially none or more than // one datasource (some_datasource and somexdatasource) would have been returned - Assert.assertEquals( + Assertions.assertEquals( someDatasourceColumns, getRows( metaData.getColumns(null, "dr_id", CalciteTests.SOME_DATSOURCE_ESCAPED, null), @@ -1566,7 +1566,7 @@ public void testEscapingForGetColumns() throws SQLException Pair.of("COLUMN_NAME", "unique_dim1_x") ) ); - Assert.assertEquals( + Assertions.assertEquals( someXDatasourceColumns, getRows( metaData.getColumns(null, "dr_id", "somexdatasource", null), @@ -1577,7 +1577,7 @@ public void testEscapingForGetColumns() throws SQLException List> columnsOfBothTables = new ArrayList<>(someDatasourceColumns); columnsOfBothTables.addAll(someXDatasourceColumns); // Assert that the pattern matching still works when no escape string is provided - Assert.assertEquals( + Assertions.assertEquals( columnsOfBothTables, getRows( metaData.getColumns(null, "dr_id", "some_datasource", null), @@ -1586,7 +1586,7 @@ public void testEscapingForGetColumns() throws SQLException ); // Assert column name pattern works correctly when _ is in the column names - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_SCHEM", "druid"), @@ -1606,7 +1606,7 @@ public void testEscapingForGetColumns() throws SQLException ); // Assert column name pattern with % works correctly for column names starting with m - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_SCHEM", "druid"), @@ -1641,7 +1641,7 @@ public void testEscapingForGetTables() throws SQLException { final DatabaseMetaData metaData = client.getMetaData(); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_SCHEM", "druid"), @@ -1654,7 +1654,7 @@ public void testEscapingForGetTables() throws SQLException ) ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_SCHEM", "druid"), @@ -1668,7 +1668,7 @@ public void testEscapingForGetTables() throws SQLException ); // Assert that some_datasource is treated as a pattern that matches some_datasource and somexdatasource - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( row( Pair.of("TABLE_SCHEM", "druid"), @@ -1693,15 +1693,15 @@ public void testArrayStuff() throws SQLException "SELECT ARRAY_AGG(dim2) AS arr1, ARRAY_AGG(l1) AS arr2, ARRAY_AGG(dbl1) AS arr3, ARRAY_AGG(f1) AS arr4 FROM druid.numfoo")) { final ResultSet resultSet = statement.executeQuery(); final List> rows = getRows(resultSet); - Assert.assertEquals(1, rows.size()); - Assert.assertTrue(rows.get(0).containsKey("arr1")); - Assert.assertTrue(rows.get(0).containsKey("arr2")); - Assert.assertTrue(rows.get(0).containsKey("arr3")); - Assert.assertTrue(rows.get(0).containsKey("arr4")); - Assert.assertArrayEquals(new Object[]{"a", null, "", "a", "abc", null}, (Object[]) rows.get(0).get("arr1")); - Assert.assertArrayEquals(new Object[]{7L, 325323L, 0L, null, null, null}, (Object[]) rows.get(0).get("arr2")); - Assert.assertArrayEquals(new Object[]{1.0, 1.7, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr3")); - Assert.assertArrayEquals(new Object[]{1.0, 0.10000000149011612, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr4")); + Assertions.assertEquals(1, rows.size()); + Assertions.assertTrue(rows.get(0).containsKey("arr1")); + Assertions.assertTrue(rows.get(0).containsKey("arr2")); + Assertions.assertTrue(rows.get(0).containsKey("arr3")); + Assertions.assertTrue(rows.get(0).containsKey("arr4")); + Assertions.assertArrayEquals(new Object[]{"a", null, "", "a", "abc", null}, (Object[]) rows.get(0).get("arr1")); + Assertions.assertArrayEquals(new Object[]{7L, 325323L, 0L, null, null, null}, (Object[]) rows.get(0).get("arr2")); + Assertions.assertArrayEquals(new Object[]{1.0, 1.7, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr3")); + Assertions.assertArrayEquals(new Object[]{1.0, 0.10000000149011612, 0.0, null, null, null}, (Object[]) rows.get(0).get("arr4")); } } @@ -1718,13 +1718,13 @@ public void testUnauthorizedTable() statement.executeQuery(query); } catch (SQLException e) { - Assert.assertEquals( + Assertions.assertEquals( e.getMessage(), expectedError ); return; } - Assert.fail("Test failed, did not get SQLException"); + Assertions.fail("Test failed, did not get SQLException"); } private static class TestResultFetcher extends ResultFetcher @@ -1849,15 +1849,15 @@ public Frame fetch( try (final Statement statement = conn.createStatement(); final ResultSet resultSet = statement.executeQuery("SELECT dim1 FROM druid.foo")) { final List> rows = getRows(resultSet); - Assert.assertEquals(6, rows.size()); - Assert.assertEquals(6, frames.size()); // 3 empty frames and then 3 frames of 2 rows each - - Assert.assertFalse(frames.get(0).rows.iterator().hasNext()); - Assert.assertFalse(frames.get(1).rows.iterator().hasNext()); - Assert.assertFalse(frames.get(2).rows.iterator().hasNext()); - Assert.assertTrue(frames.get(3).rows.iterator().hasNext()); - Assert.assertTrue(frames.get(4).rows.iterator().hasNext()); - Assert.assertTrue(frames.get(5).rows.iterator().hasNext()); + Assertions.assertEquals(6, rows.size()); + Assertions.assertEquals(6, frames.size()); // 3 empty frames and then 3 frames of 2 rows each + + Assertions.assertFalse(frames.get(0).rows.iterator().hasNext()); + Assertions.assertFalse(frames.get(1).rows.iterator().hasNext()); + Assertions.assertFalse(frames.get(2).rows.iterator().hasNext()); + Assertions.assertTrue(frames.get(3).rows.iterator().hasNext()); + Assertions.assertTrue(frames.get(4).rows.iterator().hasNext()); + Assertions.assertTrue(frames.get(5).rows.iterator().hasNext()); } } @@ -1872,12 +1872,12 @@ public Frame fetch( public void testMultiStatementFails() throws SQLException { try (Statement stmt = client.createStatement()) { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( AvaticaSqlException.class, () -> stmt.executeQuery("SET useApproxCountDistinct = true; SELECT COUNT(DISTINCT dim1) AS cnt FROM druid.foo") ); // ugly error message for statement - Assert.assertEquals( + Assertions.assertEquals( "Error -1 (00000) : Error while executing SQL \"SET useApproxCountDistinct = true; SELECT COUNT(DISTINCT dim1) AS cnt FROM druid.foo\": Remote driver error: QueryInterruptedException: SQL query string must contain only a single statement -> DruidException: SQL query string must contain only a single statement", t.getMessage() ); @@ -1887,12 +1887,12 @@ public void testMultiStatementFails() throws SQLException @Test public void testMultiPreparedStatementFails() throws SQLException { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( AvaticaSqlException.class, () -> client.prepareStatement("SET vectorize = 'force'; SELECT COUNT(*) AS cnt FROM druid.foo") ); // sad error message for prepared statement - Assert.assertEquals( + Assertions.assertEquals( "Error -1 (00000) : while preparing SQL: SET vectorize = 'force'; SELECT COUNT(*) AS cnt FROM druid.foo", t.getMessage() ); @@ -1915,11 +1915,11 @@ private void testWithJDBI(String baseUrl) int count = 0; while (iter.hasNext()) { Pair row = iter.next(); - Assert.assertNotNull(row.lhs); - Assert.assertNotNull(row.rhs); + Assertions.assertNotNull(row.lhs); + Assertions.assertNotNull(row.rhs); count++; } - Assert.assertEquals(6, count); + Assertions.assertEquals(6, count); } finally { handle.close(); @@ -1982,16 +1982,16 @@ public void testRemoteAddressInLogs() throws SQLException stmt.executeQuery("SELECT COUNT(*) AS cnt FROM druid.foo"); } - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); RequestLogLine logLine = testRequestLogger.getSqlQueryLogs().get(0); String remoteAddress = logLine.getRemoteAddr(); - Assert.assertNotNull("Remote address should not be null", remoteAddress); + Assertions.assertNotNull(remoteAddress, "Remote address should not be null"); - Assert.assertTrue( - "Remote address should be a valid IP address, got: " + remoteAddress, + Assertions.assertTrue( IPV4_PATTERN.matcher(remoteAddress).matches() || - IPV6_PATTERN.matcher(remoteAddress).matches() + IPV6_PATTERN.matcher(remoteAddress).matches(), + "Remote address should be a valid IP address, got: " + remoteAddress ); } @@ -2005,18 +2005,18 @@ public void testRemoteAddressInFailedQuery() throws SQLException try (Statement stmt = client.createStatement()) { stmt.executeQuery("SELECT nonexistent FROM druid.foo"); - Assert.fail("Query should have failed"); + Assertions.fail("Query should have failed"); } catch (SQLException e) { // Expected exception } - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); RequestLogLine logLine = testRequestLogger.getSqlQueryLogs().get(0); String remoteAddress = logLine.getRemoteAddr(); - Assert.assertNotNull("Remote address should not be null even in failed query", remoteAddress); - Assert.assertFalse("Remote address should not be empty even in failed query", remoteAddress.length() == 0); + Assertions.assertNotNull(remoteAddress, "Remote address should not be null even in failed query"); + Assertions.assertFalse(remoteAddress.length() == 0, "Remote address should not be empty even in failed query"); } /** @@ -2035,20 +2035,20 @@ public void testRemoteAddressInPreparedStatement() throws SQLException stmt.executeQuery(); } - Assert.assertFalse( - "Should have at least one log entry", - testRequestLogger.getSqlQueryLogs().isEmpty() + Assertions.assertFalse( + testRequestLogger.getSqlQueryLogs().isEmpty(), + "Should have at least one log entry" ); for (RequestLogLine logLine : testRequestLogger.getSqlQueryLogs()) { String remoteAddress = logLine.getRemoteAddr(); - Assert.assertNotNull( - "Every prepared-statement log entry must carry a remote address", - remoteAddress + Assertions.assertNotNull( + remoteAddress, + "Every prepared-statement log entry must carry a remote address" ); - Assert.assertFalse( - "Every prepared-statement log entry must carry a non-empty remote address", - remoteAddress.isEmpty() + Assertions.assertFalse( + remoteAddress.isEmpty(), + "Every prepared-statement log entry must carry a non-empty remote address" ); } } diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java index 8746a78f33ed..d2c213c8098d 100644 --- a/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java +++ b/sql/src/test/java/org/apache/druid/sql/avatica/DruidStatementTest.java @@ -31,7 +31,6 @@ import org.apache.druid.query.QueryRunnerFactoryConglomerate; import org.apache.druid.query.policy.NoopPolicyEnforcer; import org.apache.druid.segment.join.JoinableFactoryWrapper; -import org.apache.druid.server.QueryStackTests; import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker; import org.apache.druid.server.security.AllowAllAuthenticator; import org.apache.druid.server.security.AuthConfig; @@ -48,10 +47,11 @@ import org.apache.druid.sql.calcite.util.CalciteTestBase; import org.apache.druid.sql.calcite.util.CalciteTests; import org.apache.druid.sql.calcite.util.QueryFrameworkUtils; +import org.apache.druid.sql.calcite.util.SqlTestQueryStack; import org.apache.druid.sql.hook.DruidHookDispatcher; -import org.junit.Assert; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -81,7 +81,7 @@ public class DruidStatementTest extends CalciteTestBase public static void setUpClass(@TempDir File tempDir) { resourceCloser = Closer.create(); - conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(resourceCloser); + conglomerate = SqlTestQueryStack.createQueryRunnerFactoryConglomerate(resourceCloser); walker = CalciteTests.createMockWalker(conglomerate, tempDir); resourceCloser.register(walker); } @@ -162,11 +162,11 @@ public void testSubQueryWithOrderByDirect() // First frame, ask for all rows. statement.execute(queryPlus, -1, null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( subQueryWithOrderByResults(), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); } } @@ -182,14 +182,14 @@ public void testFetchPastEOFDirect() // First frame, ask for all rows. statement.execute(queryPlus, -1, null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( subQueryWithOrderByResults(), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); try { statement.nextFrame(6, 6); - Assert.fail(); + Assertions.fail(); } catch (Exception e) { // Expected: can't work with an auto-closed result set. @@ -206,7 +206,7 @@ public void testSkipExecuteDirect() try (final DruidJdbcStatement statement = jdbcStatement()) { // Error: no call to execute; statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.fail(); + Assertions.fail(); } catch (Exception e) { // Expected @@ -231,7 +231,7 @@ public void testFetchAfterResultCloseDirect() statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); statement.closeResultSet(); statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.fail(); + Assertions.fail(); } catch (Exception e) { // Expected @@ -249,20 +249,20 @@ public void testSubQueryWithOrderByDirectTwice() try (final DruidJdbcStatement statement = jdbcStatement()) { statement.execute(queryPlus, -1, null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( subQueryWithOrderByResults(), frame ); // Do it again. JDBC says we can reuse statements sequentially. - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); statement.execute(queryPlus, -1, null); frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( subQueryWithOrderByResults(), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); } } @@ -294,7 +294,7 @@ public void testSelectAllInFirstFrameDirect() // First frame, ask for all rows. statement.execute(queryPlus, -1, null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( Meta.Frame.create( 0, true, @@ -315,7 +315,7 @@ public void testSelectAllInFirstFrameDirect() ), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); } } @@ -335,23 +335,23 @@ public void testSelectSplitOverTwoFramesDirect() // First frame, ask for 2 rows. statement.execute(queryPlus, -1, null); - Assert.assertEquals(0, statement.getCurrentOffset()); - Assert.assertFalse(statement.isDone()); + Assertions.assertEquals(0, statement.getCurrentOffset()); + Assertions.assertFalse(statement.isDone()); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2); - Assert.assertEquals( + Assertions.assertEquals( firstFrameResults(), frame ); - Assert.assertFalse(statement.isDone()); - Assert.assertEquals(2, statement.getCurrentOffset()); + Assertions.assertFalse(statement.isDone()); + Assertions.assertEquals(2, statement.getCurrentOffset()); // Last frame, ask for all remaining rows. frame = statement.nextFrame(2, 10); - Assert.assertEquals( + Assertions.assertEquals( secondFrameResults(), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); } } @@ -371,28 +371,28 @@ public void testTwoFramesAutoCloseDirect() // First frame, ask for 2 rows. statement.execute(queryPlus, -1, null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2); - Assert.assertEquals( + Assertions.assertEquals( firstFrameResults(), frame ); - Assert.assertFalse(statement.isDone()); + Assertions.assertFalse(statement.isDone()); // Do it again. Closes the prior result set. statement.execute(queryPlus, -1, null); frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2); - Assert.assertEquals( + Assertions.assertEquals( firstFrameResults(), frame ); - Assert.assertFalse(statement.isDone()); + Assertions.assertFalse(statement.isDone()); // Last frame, ask for all remaining rows. frame = statement.nextFrame(2, 10); - Assert.assertEquals( + Assertions.assertEquals( secondFrameResults(), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); } } @@ -412,11 +412,11 @@ public void testTwoFramesCloseWithResultSetDirect() // First frame, ask for 2 rows. statement.execute(queryPlus, -1, null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 2); - Assert.assertEquals( + Assertions.assertEquals( firstFrameResults(), frame ); - Assert.assertFalse(statement.isDone()); + Assertions.assertFalse(statement.isDone()); // Leave result set open; close statement. } @@ -472,10 +472,10 @@ public void testSignatureDirect() @SuppressWarnings("unchecked") private void verifySignature(Meta.Signature signature) { - Assert.assertEquals(Meta.CursorFactory.ARRAY, signature.cursorFactory); - Assert.assertEquals(Meta.StatementType.SELECT, signature.statementType); - Assert.assertEquals(SELECT_STAR_FROM_FOO, signature.sql); - Assert.assertEquals( + Assertions.assertEquals(Meta.CursorFactory.ARRAY, signature.cursorFactory); + Assertions.assertEquals(Meta.StatementType.SELECT, signature.statementType); + Assertions.assertEquals(SELECT_STAR_FROM_FOO, signature.sql); + Assertions.assertEquals( Lists.newArrayList( Lists.newArrayList("__time", "TIMESTAMP", "java.math.BigDecimal"), Lists.newArrayList("dim1", "VARCHAR", "java.lang.String"), @@ -535,11 +535,11 @@ public void testSubQueryWithOrderByPrepared() // First frame, ask for all rows. statement.execute(Collections.emptyList(), null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( subQueryWithOrderByResults(), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); } } @@ -556,20 +556,20 @@ public void testSubQueryWithOrderByPreparedTwice() statement.prepare(); statement.execute(Collections.emptyList(), null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( subQueryWithOrderByResults(), frame ); // Do it again. JDBC says we can reuse prepared statements sequentially. - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); statement.execute(Collections.emptyList(), null); frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( subQueryWithOrderByResults(), frame ); - Assert.assertTrue(statement.isDone()); + Assertions.assertTrue(statement.isDone()); } } @@ -605,7 +605,7 @@ public void testParameters() // Execute many times. First time. statement.execute(matchingParams, null); Meta.Frame frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( expected, frame ); @@ -613,7 +613,7 @@ public void testParameters() // Again, same value. statement.execute(matchingParams, null); frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( expected, frame ); @@ -623,7 +623,7 @@ public void testParameters() Collections.singletonList( TypedValue.ofLocal(ColumnMetaData.Rep.STRING, "foo")), null); frame = statement.nextFrame(AbstractDruidJdbcStatement.START_OFFSET, 6); - Assert.assertEquals( + Assertions.assertEquals( Meta.Frame.create(0, true, Collections.emptyList()), frame ); diff --git a/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java b/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java index 2efa65d1a7b5..274ccd8b7505 100644 --- a/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java +++ b/sql/src/test/java/org/apache/druid/sql/avatica/ErrorHandlerTest.java @@ -24,8 +24,8 @@ import org.apache.druid.query.QueryException; import org.apache.druid.query.QueryInterruptedException; import org.apache.druid.server.initialization.ServerConfig; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ErrorHandlerTest @@ -44,7 +44,7 @@ public void testErrorHandlerSanitizesErrorAsExpected() QueryException input = new QueryException("error", "error message", "error class", "host"); RuntimeException output = errorHandler.sanitize(input); - Assert.assertNull(output.getMessage()); + Assertions.assertNull(output.getMessage()); } @Test @@ -55,7 +55,7 @@ public void testErrorHandlerDefaultErrorResponseTransformStrategySanitizesErrorA QueryInterruptedException input = new QueryInterruptedException("error", "error messagez", "error class", "host"); RuntimeException output = errorHandler.sanitize(input); - Assert.assertEquals("error messagez", output.getMessage()); + Assertions.assertEquals("error messagez", output.getMessage()); } @Test @@ -68,7 +68,7 @@ public void testErrorHandlerHasAffectingErrorResponseTransformStrategyReturnsTru Mockito.when(serverConfig.getErrorResponseTransformStrategy()) .thenReturn(emptyAllowedRegexErrorResponseTransformStrategy); ErrorHandler errorHandler = new ErrorHandler(serverConfig); - Assert.assertTrue(errorHandler.hasAffectingErrorResponseTransformStrategy()); + Assertions.assertTrue(errorHandler.hasAffectingErrorResponseTransformStrategy()); } @Test @@ -76,7 +76,7 @@ public void testErrorHandlerHasAffectingErrorResponseTransformStrategyReturnsFal { ServerConfig serverConfig = new ServerConfig(); ErrorHandler errorHandler = new ErrorHandler(serverConfig); - Assert.assertFalse(errorHandler.hasAffectingErrorResponseTransformStrategy()); + Assertions.assertFalse(errorHandler.hasAffectingErrorResponseTransformStrategy()); } @Test @@ -92,6 +92,6 @@ public void testErrorHandlerHandlesNonSanitizableExceptionCorrectly() Exception input = new Exception("message"); RuntimeException output = errorHandler.sanitize(input); - Assert.assertEquals(null, output.getMessage()); + Assertions.assertEquals(null, output.getMessage()); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java index 790c6eae3921..e6750df129ac 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/aggregation/SqlAggregationModuleTest.java @@ -25,8 +25,7 @@ import com.google.inject.TypeLiteral; import org.apache.druid.sql.calcite.aggregation.builtin.CountSqlAggregator; import org.apache.druid.sql.calcite.util.CalciteTestBase; -import org.hamcrest.CoreMatchers; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -35,8 +34,6 @@ import java.util.Set; import java.util.stream.Collectors; -import static org.hamcrest.MatcherAssert.assertThat; - public class SqlAggregationModuleTest extends CalciteTestBase { private SqlAggregationModule target; @@ -53,14 +50,14 @@ public void setUp() public void testDefaultSqlAggregatorsAreBound() { Set sqlAggregators = injector.getInstance(Key.get(new TypeLiteral<>() {})); - Assert.assertNotNull(sqlAggregators); - Assert.assertEquals(2, sqlAggregators.size()); + Assertions.assertNotNull(sqlAggregators); + Assertions.assertEquals(2, sqlAggregators.size()); final List aggregators = sqlAggregators.stream() .sorted(Comparator.comparing(o -> o.getClass().getName())) .collect(Collectors.toList()); - assertThat(aggregators.get(0), CoreMatchers.instanceOf(ApproxCountDistinctSqlAggregator.class)); - assertThat(aggregators.get(1), CoreMatchers.instanceOf(CountSqlAggregator.class)); + Assertions.assertInstanceOf(ApproxCountDistinctSqlAggregator.class, aggregators.get(0)); + Assertions.assertInstanceOf(CountSqlAggregator.class, aggregators.get(1)); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java index d0a25c59df88..b7389bb9eaac 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/DruidExpressionTest.java @@ -25,31 +25,29 @@ import org.apache.druid.math.expr.Parser; import org.apache.druid.segment.column.ColumnType; import org.apache.druid.testing.InitializedNullHandlingTest; -import org.hamcrest.CoreMatchers; -import org.hamcrest.MatcherAssert; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; public class DruidExpressionTest extends InitializedNullHandlingTest { @Test public void test_doubleLiteral_asString() { - Assert.assertEquals("0.0", DruidExpression.doubleLiteral(0)); - Assert.assertEquals("-2.0", DruidExpression.doubleLiteral(-2)); - Assert.assertEquals("2.0", DruidExpression.doubleLiteral(2)); - Assert.assertEquals("2.1", DruidExpression.doubleLiteral(2.1)); - Assert.assertEquals("2.12345678", DruidExpression.doubleLiteral(2.12345678)); - Assert.assertEquals("2.2E122", DruidExpression.doubleLiteral(2.2e122)); - Assert.assertEquals("NaN", DruidExpression.doubleLiteral(Double.NaN)); - Assert.assertEquals("Infinity", DruidExpression.doubleLiteral(Double.POSITIVE_INFINITY)); - Assert.assertEquals("-Infinity", DruidExpression.doubleLiteral(Double.NEGATIVE_INFINITY)); + Assertions.assertEquals("0.0", DruidExpression.doubleLiteral(0)); + Assertions.assertEquals("-2.0", DruidExpression.doubleLiteral(-2)); + Assertions.assertEquals("2.0", DruidExpression.doubleLiteral(2)); + Assertions.assertEquals("2.1", DruidExpression.doubleLiteral(2.1)); + Assertions.assertEquals("2.12345678", DruidExpression.doubleLiteral(2.12345678)); + Assertions.assertEquals("2.2E122", DruidExpression.doubleLiteral(2.2e122)); + Assertions.assertEquals("NaN", DruidExpression.doubleLiteral(Double.NaN)); + Assertions.assertEquals("Infinity", DruidExpression.doubleLiteral(Double.POSITIVE_INFINITY)); + Assertions.assertEquals("-Infinity", DruidExpression.doubleLiteral(Double.NEGATIVE_INFINITY)); //CHECKSTYLE.OFF: Regexp // Min/max double are banned by regexp due to often being inappropriate; but they are appropriate here. - Assert.assertEquals("4.9E-324", DruidExpression.doubleLiteral(Double.MIN_VALUE)); - Assert.assertEquals("1.7976931348623157E308", DruidExpression.doubleLiteral(Double.MAX_VALUE)); + Assertions.assertEquals("4.9E-324", DruidExpression.doubleLiteral(Double.MIN_VALUE)); + Assertions.assertEquals("1.7976931348623157E308", DruidExpression.doubleLiteral(Double.MAX_VALUE)); //CHECKSTYLE.ON: Regexp - Assert.assertEquals("2.2250738585072014E-308", DruidExpression.doubleLiteral(Double.MIN_NORMAL)); + Assertions.assertEquals("2.2250738585072014E-308", DruidExpression.doubleLiteral(Double.MIN_NORMAL)); } @Test @@ -75,20 +73,20 @@ public void test_doubleLiteral_roundTrip() for (double n : doubles) { final Expr expr = Parser.parse(DruidExpression.doubleLiteral(n), ExprMacroTable.nil()); - Assert.assertTrue(expr.isLiteral()); - MatcherAssert.assertThat(expr.getLiteralValue(), CoreMatchers.instanceOf(Double.class)); - Assert.assertEquals(n, (double) expr.getLiteralValue(), 0d); + Assertions.assertTrue(expr.isLiteral()); + Assertions.assertInstanceOf(Double.class, expr.getLiteralValue()); + Assertions.assertEquals(n, (double) expr.getLiteralValue(), 0d); } } @Test public void test_longLiteral_asString() { - Assert.assertEquals("0", DruidExpression.longLiteral(0)); - Assert.assertEquals("-2", DruidExpression.longLiteral(-2)); - Assert.assertEquals("2", DruidExpression.longLiteral(2)); - Assert.assertEquals("9223372036854775807", DruidExpression.longLiteral(Long.MAX_VALUE)); - Assert.assertEquals("-9223372036854775808", DruidExpression.longLiteral(Long.MIN_VALUE)); + Assertions.assertEquals("0", DruidExpression.longLiteral(0)); + Assertions.assertEquals("-2", DruidExpression.longLiteral(-2)); + Assertions.assertEquals("2", DruidExpression.longLiteral(2)); + Assertions.assertEquals("9223372036854775807", DruidExpression.longLiteral(Long.MAX_VALUE)); + Assertions.assertEquals("-9223372036854775808", DruidExpression.longLiteral(Long.MIN_VALUE)); } @Test @@ -104,9 +102,9 @@ public void test_longLiteral_roundTrip() for (long n : longs) { final Expr expr = Parser.parse(DruidExpression.longLiteral(n), ExprMacroTable.nil()); - Assert.assertTrue(expr.isLiteral()); - MatcherAssert.assertThat(expr.getLiteralValue(), CoreMatchers.instanceOf(Number.class)); - Assert.assertEquals(n, ((Number) expr.getLiteralValue()).longValue()); + Assertions.assertTrue(expr.isLiteral()); + Assertions.assertInstanceOf(Number.class, expr.getLiteralValue()); + Assertions.assertEquals(n, ((Number) expr.getLiteralValue()).longValue()); } } @@ -115,8 +113,8 @@ public void test_ofLiteral_nullString() { final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, null)); - Assert.assertEquals(ColumnType.STRING, expression.getDruidType()); - Assert.assertEquals("null", expression.getExpression()); + Assertions.assertEquals(ColumnType.STRING, expression.getDruidType()); + Assertions.assertEquals("null", expression.getExpression()); } @Test @@ -124,8 +122,8 @@ public void test_ofLiteral_nullLong() { final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.LONG, null)); - Assert.assertEquals(ColumnType.LONG, expression.getDruidType()); - Assert.assertEquals("null", expression.getExpression()); + Assertions.assertEquals(ColumnType.LONG, expression.getDruidType()); + Assertions.assertEquals("null", expression.getExpression()); } @Test @@ -133,8 +131,8 @@ public void test_ofLiteral_nullDouble() { final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, null)); - Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); - Assert.assertEquals("null", expression.getExpression()); + Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); + Assertions.assertEquals("null", expression.getExpression()); } @Test @@ -143,8 +141,8 @@ public void test_ofLiteral_nullArray() final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING_ARRAY, null)); - Assert.assertEquals(ColumnType.STRING_ARRAY, expression.getDruidType()); - Assert.assertEquals("null", expression.getExpression()); + Assertions.assertEquals(ColumnType.STRING_ARRAY, expression.getDruidType()); + Assertions.assertEquals("null", expression.getExpression()); } @Test @@ -153,9 +151,9 @@ public void test_ofLiteral_string() final String s = "abcdé\n \\\" ' \uD83E\uDD20 \txyz"; final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, s)); - Assert.assertEquals(ColumnType.STRING, expression.getDruidType()); - Assert.assertEquals("'abcdé\\u000A \\u005C\\u0022 \\u0027 \\uD83E\\uDD20 \\u0009xyz'", expression.getExpression()); - Assert.assertEquals(s, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); + Assertions.assertEquals(ColumnType.STRING, expression.getDruidType()); + Assertions.assertEquals("'abcdé\\u000A \\u005C\\u0022 \\u0027 \\uD83E\\uDD20 \\u0009xyz'", expression.getExpression()); + Assertions.assertEquals(s, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); } @Test @@ -164,9 +162,9 @@ public void test_ofLiteral_emptyString() final String s = ""; final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.STRING, s)); - Assert.assertEquals(ColumnType.STRING, expression.getDruidType()); - Assert.assertEquals("''", expression.getExpression()); - Assert.assertEquals( + Assertions.assertEquals(ColumnType.STRING, expression.getDruidType()); + Assertions.assertEquals("''", expression.getExpression()); + Assertions.assertEquals( s, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue() ); @@ -177,9 +175,9 @@ public void test_ofLiteral_long() { final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.LONG, -123)); - Assert.assertEquals(ColumnType.LONG, expression.getDruidType()); - Assert.assertEquals("-123", expression.getExpression()); - Assert.assertEquals(-123L, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); + Assertions.assertEquals(ColumnType.LONG, expression.getDruidType()); + Assertions.assertEquals("-123", expression.getExpression()); + Assertions.assertEquals(-123L, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); } @Test @@ -187,9 +185,9 @@ public void test_ofLiteral_double() { final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, -123.4)); - Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); - Assert.assertEquals("-123.4", expression.getExpression()); - Assert.assertEquals(-123.4, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); + Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); + Assertions.assertEquals("-123.4", expression.getExpression()); + Assertions.assertEquals(-123.4, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); } @Test @@ -197,9 +195,9 @@ public void test_ofLiteral_doubleNan() { final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.NaN)); - Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); - Assert.assertEquals("NaN", expression.getExpression()); - Assert.assertEquals(Double.NaN, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); + Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); + Assertions.assertEquals("NaN", expression.getExpression()); + Assertions.assertEquals(Double.NaN, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue()); } @Test @@ -208,9 +206,9 @@ public void test_ofLiteral_doubleNegativeInfinity() final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.NEGATIVE_INFINITY)); - Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); - Assert.assertEquals("-Infinity", expression.getExpression()); - Assert.assertEquals( + Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); + Assertions.assertEquals("-Infinity", expression.getExpression()); + Assertions.assertEquals( Double.NEGATIVE_INFINITY, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue() ); @@ -222,9 +220,9 @@ public void test_ofLiteral_doublePositiveInfinity() final DruidExpression expression = DruidExpression.ofLiteral(new DruidLiteral(ExpressionType.DOUBLE, Double.POSITIVE_INFINITY)); - Assert.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); - Assert.assertEquals("Infinity", expression.getExpression()); - Assert.assertEquals( + Assertions.assertEquals(ColumnType.DOUBLE, expression.getDruidType()); + Assertions.assertEquals("Infinity", expression.getExpression()); + Assertions.assertEquals( Double.POSITIVE_INFINITY, Parser.parse(expression.getExpression(), ExprMacroTable.nil()).getLiteralValue() ); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java index 7f1ef2400fb6..ee7f03e87643 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionTestHelper.java @@ -67,9 +67,10 @@ import org.easymock.EasyMock; import org.joda.time.DateTime; import org.joda.time.DateTimeZone; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import javax.annotation.Nullable; + import java.math.BigDecimal; import java.util.Arrays; import java.util.Collections; @@ -334,18 +335,18 @@ void testExpression( ) { DruidExpression expression = Expressions.toDruidExpression(PLANNER_CONTEXT, rowSignature, rexNode); - Assert.assertNotNull(expression); + Assertions.assertNotNull(expression); if (deepCompare) { - Assert.assertEquals("Expression for: " + rexNode, expectedExpression, expression); + Assertions.assertEquals(expectedExpression, expression, "Expression for: " + rexNode); } else { - Assert.assertEquals("Expression for: " + rexNode, expectedExpression.getExpression(), expression.getExpression()); + Assertions.assertEquals(expectedExpression.getExpression(), expression.getExpression(), "Expression for: " + rexNode); } ExprEval result = PLANNER_CONTEXT.parseExpression(expression.getExpression()) .eval(expressionBindings); - Assert.assertEquals("Result for: " + rexNode, expectedResult, result.value()); + Assertions.assertEquals(expectedResult, result.value(), "Result for: " + rexNode); } void testFilter( @@ -364,7 +365,7 @@ void testFilter( ); final DimFilter filter = Expressions.toFilter(PLANNER_CONTEXT, rowSignature, virtualColumnRegistry, rexNode); - Assert.assertEquals("Filter for: " + rexNode, expectedFilter, filter); + Assertions.assertEquals(expectedFilter, filter, "Filter for: " + rexNode); final List virtualColumns = filter.getRequiredColumns() @@ -374,12 +375,12 @@ void testFilter( .sorted(Comparator.comparing(VirtualColumn::getOutputName)) .collect(Collectors.toList()); - Assert.assertEquals( - "Virtual columns for: " + rexNode, + Assertions.assertEquals( expectedVirtualColumns.stream() .sorted(Comparator.comparing(VirtualColumn::getOutputName)) .collect(Collectors.toList()), - virtualColumns + virtualColumns, + "Virtual columns for: " + rexNode ); final ValueMatcher matcher = expectedFilter.toFilter().makeMatcher( @@ -394,6 +395,6 @@ void testFilter( ) ); - Assert.assertEquals("Result for: " + rexNode, expectedResult, matcher.matches(false)); + Assertions.assertEquals(expectedResult, matcher.matches(false), "Result for: " + rexNode); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java index fe413defa223..ecb6f4d310c2 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/ExpressionsTest.java @@ -75,10 +75,9 @@ import org.apache.druid.sql.calcite.planner.PlannerContext; import org.apache.druid.sql.calcite.rel.CannotBuildQueryException; import org.apache.druid.sql.calcite.util.CalciteTestBase; -import org.hamcrest.core.StringContains; import org.joda.time.DateTimeZone; import org.joda.time.Period; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -87,8 +86,6 @@ import java.util.Collections; import java.util.Map; -import static org.hamcrest.MatcherAssert.assertThat; - public class ExpressionsTest extends CalciteTestBase { private static final RowSignature ROW_SIGNATURE = RowSignature @@ -1280,7 +1277,7 @@ public void testRoundWithInvalidSecondArgument() { final SqlOperator roundFunction = getOperatorConversion(SqlStdOperatorTable.ROUND).calciteOperator(); - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( DruidException.class, () -> testHelper.testExpressionString( roundFunction, @@ -1299,7 +1296,7 @@ public void testRoundWithInvalidSecondArgument() "IAE Exception" ) ); - Assert.assertEquals("Function[round] second argument should be a LONG but got STRING instead", t.getMessage()); + Assertions.assertEquals("Function[round] second argument should be a LONG but got STRING instead", t.getMessage()); } @Test @@ -2303,7 +2300,7 @@ public void testRight() @Test public void testAbnormalRightWithNegativeNumber() { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( DruidException.class, () -> testHelper.testExpressionString( new RightOperatorConversion().calciteOperator(), @@ -2315,7 +2312,7 @@ public void testAbnormalRightWithNegativeNumber() null ) ); - Assert.assertEquals("Function[right] needs a positive integer as the second argument", t.getMessage()); + Assertions.assertEquals("Function[right] needs a positive integer as the second argument", t.getMessage()); } @Test @@ -2375,7 +2372,7 @@ public void testLeft() @Test public void testAbnormalLeftWithNegativeNumber() { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( DruidException.class, () -> testHelper.testExpressionString( new LeftOperatorConversion().calciteOperator(), @@ -2387,7 +2384,7 @@ public void testAbnormalLeftWithNegativeNumber() null ) ); - Assert.assertEquals("Function[left] needs a positive integer as the second argument", t.getMessage()); + Assertions.assertEquals("Function[left] needs a positive integer as the second argument", t.getMessage()); } @Test @@ -2739,12 +2736,12 @@ public void testPresenceOfOverIsInvalid() false ); - CannotBuildQueryException t = Assert.assertThrows( + CannotBuildQueryException t = Assertions.assertThrows( CannotBuildQueryException.class, () -> testHelper.testExpression(rexNode, null, plannerContext) ); - assertThat(t.getMessage(), StringContains.containsString("Unexpected OVER expression")); + Assertions.assertTrue(t.getMessage().contains("Unexpected OVER expression")); } @Test @@ -2889,7 +2886,7 @@ public void testCalciteLiteralToDruidLiteral() ) ); - Assert.assertNull( + Assertions.assertNull( Expressions.calciteLiteralToDruidLiteral( plannerContext, rexBuilder.makeCast( @@ -2910,7 +2907,7 @@ private void assertDruidLiteral( final DruidLiteral actual ) { - Assert.assertEquals( + Assertions.assertEquals( StringUtils.format("%s: %s", expected.type(), expected.value()), StringUtils.format("%s: %s", actual.type(), actual.value()) ); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java index 2bb0116825af..6a15708b072f 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressMatchExpressionTest.java @@ -26,7 +26,7 @@ import org.apache.druid.segment.column.RowSignature; import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressMatchOperatorConversion; import org.apache.druid.sql.calcite.util.CalciteTestBase; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -67,7 +67,7 @@ public void setUp() @Test public void testTooFewArgs() { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Collections.emptyList(), @@ -75,7 +75,7 @@ public void testTooFewArgs() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage()); + Assertions.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage()); } @Test @@ -83,7 +83,7 @@ public void testTooManyArgs() { String address = IPV4; String subnet = SUBNET_192_168; - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Arrays.asList( @@ -95,7 +95,7 @@ public void testTooManyArgs() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage()); + Assertions.assertEquals("Function[ipv4_match] requires 2 arguments", t.getMessage()); } @Test @@ -103,7 +103,7 @@ public void testSubnetArgNotLiteral() { String address = IPV4; String variableName = VAR; - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Arrays.asList( @@ -114,7 +114,7 @@ public void testSubnetArgNotLiteral() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_match] subnet argument must be a literal", t.getMessage()); + Assertions.assertEquals("Function[ipv4_match] subnet argument must be a literal", t.getMessage()); } @Test @@ -122,7 +122,7 @@ public void testSubnetArgInvalid() { String address = IPV4; String invalidSubnet = "192.168.0.1/invalid"; - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Arrays.asList( @@ -133,7 +133,7 @@ public void testSubnetArgInvalid() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_match] subnet arg has an invalid format: 192.168.0.1/invalid", t.getMessage()); + Assertions.assertEquals("Function[ipv4_match] subnet arg has an invalid format: 192.168.0.1/invalid", t.getMessage()); } @Test diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java index 65ea14d8f875..d9f42d23a2da 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressParseExpressionTest.java @@ -26,7 +26,7 @@ import org.apache.druid.segment.column.RowSignature; import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressParseOperatorConversion; import org.apache.druid.sql.calcite.util.CalciteTestBase; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -58,7 +58,7 @@ public void setUp() @Test public void testTooFewArgs() { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Collections.emptyList(), @@ -66,13 +66,13 @@ public void testTooFewArgs() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage()); + Assertions.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage()); } @Test public void testTooManyArgs() { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Arrays.asList( @@ -83,7 +83,7 @@ public void testTooManyArgs() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage()); + Assertions.assertEquals("Function[ipv4_parse] requires 1 argument", t.getMessage()); } @Test diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java index f1844fb940e8..a50b92321ad5 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/IPv4AddressStringifyExpressionTest.java @@ -26,7 +26,7 @@ import org.apache.druid.segment.column.RowSignature; import org.apache.druid.sql.calcite.expression.builtin.IPv4AddressStringifyOperatorConversion; import org.apache.druid.sql.calcite.util.CalciteTestBase; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -59,7 +59,7 @@ public void setUp() @Test public void testTooFewArgs() { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Collections.emptyList(), @@ -67,13 +67,13 @@ public void testTooFewArgs() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage()); + Assertions.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage()); } @Test public void testTooManyArgs() { - Throwable t = Assert.assertThrows( + Throwable t = Assertions.assertThrows( ExpressionValidationException.class, () -> testExpression( Arrays.asList( @@ -84,7 +84,7 @@ public void testTooManyArgs() IGNORE_EXPECTED_RESULT ) ); - Assert.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage()); + Assertions.assertEquals("Function[ipv4_stringify] requires 1 argument", t.getMessage()); } @Test diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java index 20369bfcf051..486e48349b83 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/expression/OperatorConversionsTest.java @@ -38,10 +38,9 @@ import org.apache.calcite.sql.validate.SqlValidatorScope; import org.apache.druid.java.util.common.StringUtils; import org.apache.druid.sql.calcite.planner.DruidTypeSystem; -import org.junit.Assert; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.ExpectedException; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; import org.mockito.stubbing.Answer; @@ -51,11 +50,9 @@ public class OperatorConversionsTest { - public static class DefaultOperandTypeCheckerTest + @Nested + public class DefaultOperandTypeCheckerTest { - @Rule - public ExpectedException expectedException = ExpectedException.none(); - @Test public void testGetOperandCountRange() { @@ -67,8 +64,8 @@ public void testGetOperandCountRange() .literalOperands() .build(); SqlOperandCountRange countRange = typeChecker.getOperandCountRange(); - Assert.assertEquals(2, countRange.getMin()); - Assert.assertEquals(3, countRange.getMax()); + Assertions.assertEquals(2, countRange.getMin()); + Assertions.assertEquals(3, countRange.getMax()); } @Test @@ -81,9 +78,9 @@ public void testIsOptional() .requiredOperandCount(2) .literalOperands() .build(); - Assert.assertFalse(typeChecker.isOptional(0)); - Assert.assertFalse(typeChecker.isOptional(1)); - Assert.assertTrue(typeChecker.isOptional(2)); + Assertions.assertFalse(typeChecker.isOptional(0)); + Assertions.assertFalse(typeChecker.isOptional(1)); + Assertions.assertTrue(typeChecker.isOptional(2)); } @Test @@ -96,7 +93,7 @@ public void testAllowFullOperands() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertTrue( + Assertions.assertTrue( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -119,7 +116,7 @@ public void testRequiredOperandsOnly() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertTrue( + Assertions.assertTrue( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -141,7 +138,7 @@ public void testLiteralOperandCheckLiteral() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertFalse( + Assertions.assertFalse( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -163,14 +160,15 @@ public void testLiteralOperandCheckLiteralThrow() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - expectedException.expect(CalciteContextException.class); - expectedException.expectMessage("Argument to function 'testLiteralOperandCheckLiteralThrow' must be a literal"); - typeChecker.checkOperandTypes( - mockCallBinding( - function, - ImmutableList.of(new OperandSpec(SqlTypeName.INTEGER, false)) + assertThrowsWithMessage( + () -> typeChecker.checkOperandTypes( + mockCallBinding( + function, + ImmutableList.of(new OperandSpec(SqlTypeName.INTEGER, false)) + ), + true ), - true + "Argument to function 'testLiteralOperandCheckLiteralThrow' must be a literal" ); } @@ -184,7 +182,7 @@ public void testAnyTypeOperand() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertTrue( + Assertions.assertTrue( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -205,7 +203,7 @@ public void testCastableFromDateTimestampToDatetimeFamily() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertTrue( + Assertions.assertTrue( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -214,7 +212,7 @@ public void testCastableFromDateTimestampToDatetimeFamily() true ) ); - Assert.assertTrue( + Assertions.assertTrue( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -235,7 +233,7 @@ public void testNullForNullableOperand() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertTrue( + Assertions.assertTrue( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -259,7 +257,7 @@ public void testNullLiteralForNullableOperand() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertTrue( + Assertions.assertTrue( typeChecker.checkOperandTypes( mockCallBinding( function, @@ -289,9 +287,9 @@ public void testNullForNullableOperandNonNullOutput() new OperandSpec(SqlTypeName.CHAR, false, true) ) ); - Assert.assertTrue(typeChecker.checkOperandTypes(binding, true)); + Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true)); RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding); - Assert.assertFalse(returnType.isNullable()); + Assertions.assertFalse(returnType.isNullable()); } @Test @@ -310,9 +308,9 @@ public void testNullForNullableOperandCascadeNullOutput() new OperandSpec(SqlTypeName.CHAR, false, true) ) ); - Assert.assertTrue(typeChecker.checkOperandTypes(binding, true)); + Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true)); RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding); - Assert.assertTrue(returnType.isNullable()); + Assertions.assertTrue(returnType.isNullable()); } @Test @@ -331,9 +329,9 @@ public void testNullForNullableOperandAlwaysNullableOutput() new OperandSpec(SqlTypeName.CHAR, false, false) ) ); - Assert.assertTrue(typeChecker.checkOperandTypes(binding, true)); + Assertions.assertTrue(typeChecker.checkOperandTypes(binding, true)); RelDataType returnType = function.getReturnTypeInference().inferReturnType(binding); - Assert.assertTrue(returnType.isNullable()); + Assertions.assertTrue(returnType.isNullable()); } @Test @@ -346,19 +344,18 @@ public void testNullForNonNullableOperand() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - expectedException.expect(CalciteContextException.class); - expectedException.expectMessage( - "Exception in test for operator[testNullForNonNullableOperand]: Illegal use of 'NULL'" - ); - typeChecker.checkOperandTypes( - mockCallBinding( - function, - ImmutableList.of( - new OperandSpec(SqlTypeName.NULL, false), - new OperandSpec(SqlTypeName.INTERVAL_HOUR, false) - ) + assertThrowsWithMessage( + () -> typeChecker.checkOperandTypes( + mockCallBinding( + function, + ImmutableList.of( + new OperandSpec(SqlTypeName.NULL, false), + new OperandSpec(SqlTypeName.INTERVAL_HOUR, false) + ) + ), + true ), - true + "Exception in test for operator[testNullForNonNullableOperand]: Illegal use of 'NULL'" ); } @@ -372,19 +369,18 @@ public void testNullLiteralForNonNullableOperand() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - expectedException.expect(CalciteContextException.class); - expectedException.expectMessage( - "Exception in test for operator[testNullLiteralForNonNullableOperand]: Illegal use of 'NULL'" - ); - typeChecker.checkOperandTypes( - mockCallBinding( - function, - ImmutableList.of( - new OperandSpec(SqlTypeName.NULL, true), - new OperandSpec(SqlTypeName.INTERVAL_HOUR, false) - ) + assertThrowsWithMessage( + () -> typeChecker.checkOperandTypes( + mockCallBinding( + function, + ImmutableList.of( + new OperandSpec(SqlTypeName.NULL, true), + new OperandSpec(SqlTypeName.INTERVAL_HOUR, false) + ) + ), + true ), - true + "Exception in test for operator[testNullLiteralForNonNullableOperand]: Illegal use of 'NULL'" ); } @@ -398,22 +394,27 @@ public void testNonCastableType() .returnTypeNonNull(SqlTypeName.CHAR) .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - expectedException.expect(CalciteContextException.class); - expectedException.expectMessage( - "Exception in test for operator[testNonCastableType]: Cannot apply 'testNonCastableType' to arguments of type" - ); - typeChecker.checkOperandTypes( - mockCallBinding( - function, - ImmutableList.of( - new OperandSpec(SqlTypeName.INTEGER, true), - new OperandSpec(SqlTypeName.INTERVAL_HOUR, false) - ) + assertThrowsWithMessage( + () -> typeChecker.checkOperandTypes( + mockCallBinding( + function, + ImmutableList.of( + new OperandSpec(SqlTypeName.INTEGER, true), + new OperandSpec(SqlTypeName.INTERVAL_HOUR, false) + ) + ), + true ), - true + "Exception in test for operator[testNonCastableType]: Cannot apply 'testNonCastableType' to arguments of type" ); } + private static void assertThrowsWithMessage(Runnable runnable, String expectedMessage) + { + final CalciteContextException e = Assertions.assertThrows(CalciteContextException.class, runnable::run); + Assertions.assertTrue(e.getMessage().contains(expectedMessage), e.getMessage()); + } + @Test public void testSignatureWithNames() { @@ -426,7 +427,7 @@ public void testSignatureWithNames() .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertEquals( + Assertions.assertEquals( "'testSignatureWithNames(, [, []])'", typeChecker.getAllowedSignatures(function, function.getName()) ); @@ -443,7 +444,7 @@ public void testSignatureWithoutNames() .build(); SqlOperandTypeChecker typeChecker = function.getOperandTypeChecker(); - Assert.assertEquals( + Assertions.assertEquals( "'testSignatureWithoutNames(, [, []])'", typeChecker.getAllowedSignatures(function, function.getName()) ); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java index be939fd58ae5..45f83af822c5 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/external/ExternalTableScanRuleTest.java @@ -43,8 +43,8 @@ import org.apache.druid.sql.calcite.util.CalciteTests; import org.apache.druid.sql.hook.DruidHookDispatcher; import org.easymock.EasyMock; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.Collections; @@ -93,7 +93,7 @@ NamedViewSchema.NAME, new NamedViewSchema(EasyMock.createMock(ViewSchema.class)) ExternalTableScanRule rule = new ExternalTableScanRule(plannerContext); rule.matches(EasyMock.createMock(RelOptRuleCall.class)); - Assert.assertEquals( + Assertions.assertEquals( "Cannot use [EXTERN] with SQL engine [native].", plannerContext.getPlanningError() ); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java index 6088ffb64541..3c578f9d44a0 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/CombineAndSimplifyBoundsTest.java @@ -30,7 +30,7 @@ import java.util.List; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; public class CombineAndSimplifyBoundsTest extends BaseCalciteQueryTest { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java index b88c520e5229..d6b52f815639 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/filtration/FiltrationTest.java @@ -27,7 +27,7 @@ import org.apache.druid.segment.column.ColumnType; import org.apache.druid.segment.column.RowSignature; import org.apache.druid.sql.calcite.util.CalciteTestBase; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; public class FiltrationTest extends CalciteTestBase @@ -46,12 +46,12 @@ public void testNotIntervals() null ).optimize(RowSignature.builder().add(ColumnHolder.TIME_COLUMN_NAME, ColumnType.LONG).build()); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of(Filtration.eternity()), filtration.getIntervals() ); - Assert.assertEquals( + Assertions.assertEquals( new NotDimFilter( new IntervalDimFilter( ColumnHolder.TIME_COLUMN_NAME, diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java index fc62cb05fba7..cbe554667b34 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/http/SqlQueryTest.java @@ -32,7 +32,7 @@ import org.apache.druid.sql.http.ResultFormat; import org.apache.druid.sql.http.SqlParameter; import org.apache.druid.sql.http.SqlQuery; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; public class SqlQueryTest extends CalciteTestBase @@ -51,7 +51,7 @@ public void testSerde() throws Exception ImmutableMap.of("useCache", false), ImmutableList.of(new SqlParameter(SqlType.INTEGER, 1)) ); - Assert.assertEquals(query, JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(query), SqlQuery.class)); + Assertions.assertEquals(query, JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(query), SqlQuery.class)); } @Test @@ -79,7 +79,7 @@ public void testClientSqlQueryToSqlQueryConversion() throws JsonProcessingExcept final SqlQuery observedSqlQuery = JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(givenClientSqlQuery), SqlQuery.class); - Assert.assertEquals(expectedSqlQuery, observedSqlQuery); + Assertions.assertEquals(expectedSqlQuery, observedSqlQuery); } @Test @@ -107,7 +107,7 @@ public void testClientSqlQueryToSqlQueryConversion2() throws JsonProcessingExcep final SqlQuery observedSqlQuery = JSON_MAPPER.readValue(JSON_MAPPER.writeValueAsString(givenClientSqlQuery), SqlQuery.class); - Assert.assertEquals(expectedSqlQuery, observedSqlQuery); + Assertions.assertEquals(expectedSqlQuery, observedSqlQuery); } @Test diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java index 651b8f712f7e..e9019e6f8229 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserTest.java @@ -25,8 +25,8 @@ import org.apache.calcite.util.DateString; import org.apache.calcite.util.TimestampString; import org.apache.druid.error.DruidException; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; public class DruidSqlParserTest { @@ -34,21 +34,21 @@ public class DruidSqlParserTest public void test_sqlLiteralToContextValue_null() { final SqlLiteral literal = SqlLiteral.createNull(SqlParserPos.ZERO); - Assert.assertNull(DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertNull(DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test public void test_sqlLiteralToContextValue_string() { final SqlLiteral literal = SqlLiteral.createCharString("abc", SqlParserPos.ZERO); - Assert.assertEquals("abc", DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals("abc", DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test public void test_sqlLiteralToContextValue_stringWithSpecialChars() { final SqlLiteral literal = SqlLiteral.createCharString("hello\nworld\t\"test\"", SqlParserPos.ZERO); - Assert.assertEquals("hello\nworld\t\"test\"", DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals("hello\nworld\t\"test\"", DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test @@ -56,14 +56,14 @@ public void test_sqlLiteralToContextValue_integer() { // Numbers within Long range are converted to Long. final SqlLiteral literal = SqlLiteral.createExactNumeric("42", SqlParserPos.ZERO); - Assert.assertEquals(42L, DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals(42L, DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test public void test_sqlLiteralToContextValue_negativeInteger() { final SqlLiteral literal = SqlLiteral.createExactNumeric("-123", SqlParserPos.ZERO); - Assert.assertEquals(-123L, DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals(-123L, DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test @@ -71,7 +71,7 @@ public void test_sqlLiteralToContextValue_decimal() { // Decimals are converted to Double. final SqlLiteral literal = SqlLiteral.createExactNumeric("3.14159", SqlParserPos.ZERO); - Assert.assertEquals(3.14159, DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals(3.14159, DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test @@ -79,28 +79,28 @@ public void test_sqlLiteralToContextValue_largeNumber() { // Integers outside Long range are retained as strings. final SqlLiteral literal = SqlLiteral.createExactNumeric("123456789012345678901234567890", SqlParserPos.ZERO); - Assert.assertEquals("123456789012345678901234567890", DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals("123456789012345678901234567890", DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test public void test_sqlLiteralToContextValue_approximateNumeric() { final SqlLiteral literal = SqlLiteral.createApproxNumeric("1.23E10", SqlParserPos.ZERO); - Assert.assertEquals(1.23E10, DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals(1.23E10, DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test public void test_sqlLiteralToContextValue_booleanTrue() { final SqlLiteral literal = SqlLiteral.createBoolean(true, SqlParserPos.ZERO); - Assert.assertEquals(true, DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals(true, DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test public void test_sqlLiteralToContextValue_booleanFalse() { final SqlLiteral literal = SqlLiteral.createBoolean(false, SqlParserPos.ZERO); - Assert.assertEquals(false, DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals(false, DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test @@ -110,7 +110,7 @@ public void test_sqlLiteralToContextValue_timestamp() final TimestampString timestampString = new TimestampString("2023-01-15 14:30:00"); final SqlLiteral literal = SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, timestampString, 0, SqlParserPos.ZERO); - Assert.assertEquals("2023-01-15T14:30:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals("2023-01-15T14:30:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test @@ -119,7 +119,7 @@ public void test_sqlLiteralToContextValue_timestampWithFractionalSeconds() final TimestampString timestampString = new TimestampString("2023-01-15 14:30:00.123"); final SqlLiteral literal = SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, timestampString, 3, SqlParserPos.ZERO); - Assert.assertEquals("2023-01-15T14:30:00.123Z", DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals("2023-01-15T14:30:00.123Z", DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test @@ -127,29 +127,29 @@ public void test_sqlLiteralToContextValue_date() { final DateString dateString = new DateString("2023-01-15"); final SqlLiteral literal = SqlLiteral.createDate(dateString, SqlParserPos.ZERO); - Assert.assertEquals("2023-01-15T00:00:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal)); + Assertions.assertEquals("2023-01-15T00:00:00.000Z", DruidSqlParser.sqlLiteralToContextValue(literal)); } @Test public void test_sqlLiteralToContextValue_unsupportedType() { final SqlLiteral literal = SqlLiteral.createSymbol(SqlTypeName.BINARY, SqlParserPos.ZERO); - final DruidException exception = Assert.assertThrows( + final DruidException exception = Assertions.assertThrows( DruidException.class, () -> DruidSqlParser.sqlLiteralToContextValue(literal) ); - Assert.assertTrue(exception.getMessage().contains("Unsupported type for SET")); + Assertions.assertTrue(exception.getMessage().contains("Unsupported type for SET")); } @Test public void testParse_reservedKeywordIdentifier() { - final DruidException exception = Assert.assertThrows( + final DruidException exception = Assertions.assertThrows( DruidException.class, () -> DruidSqlParser.parse("SELECT start FROM sys.\"segments\" LIMIT 1", false) ); - Assert.assertEquals( + Assertions.assertEquals( "Token [start] (line [1], column [8]) is a reserved keyword. " + "To use it as an identifier, quote it as [\"start\"]", exception.getMessage() @@ -159,35 +159,35 @@ public void testParse_reservedKeywordIdentifier() @Test public void testParse_reservedKeywordOutsideIdentifierContext() { - final DruidException exception = Assert.assertThrows( + final DruidException exception = Assertions.assertThrows( DruidException.class, () -> DruidSqlParser.parse("SELECT * FROM foo GROUP ORDER BY x", false) ); - Assert.assertFalse(exception.getMessage().contains("is a reserved keyword")); + Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword")); } @Test public void testParse_expectedReservedKeyword() { - final DruidException exception = Assert.assertThrows( + final DruidException exception = Assertions.assertThrows( DruidException.class, () -> DruidSqlParser.parse("SELECT a FROM", false) ); - Assert.assertFalse(exception.getMessage().contains("is a reserved keyword")); + Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword")); } @Test public void testParse_reservedKeywordFunctionCall() { // UNNEST is a reserved keyword, but it appears in a function-call context, not as an identifier. - final DruidException exception = Assert.assertThrows( + final DruidException exception = Assertions.assertThrows( DruidException.class, () -> DruidSqlParser.parse("SELECT strlen(unnest(a_int))", false) ); - Assert.assertTrue(exception.getMessage().contains("Received an unexpected token")); - Assert.assertFalse(exception.getMessage().contains("is a reserved keyword")); + Assertions.assertTrue(exception.getMessage().contains("Received an unexpected token")); + Assertions.assertFalse(exception.getMessage().contains("is a reserved keyword")); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java index b51a106aef93..47f37952bd30 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java @@ -48,22 +48,24 @@ import org.joda.time.DateTime; import org.joda.time.DateTimeZone; import org.joda.time.Period; -import org.junit.Assert; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import java.util.Arrays; +import java.util.stream.Stream; public class DruidSqlParserUtilsTest { /** * Sanity checking that the formats of TIME_FLOOR(__time, Period) work as expected */ - @RunWith(Parameterized.class) - public static class TimeFloorToGranularityConversionTest + @Nested + public class TimeFloorToGranularityConversionTest { - @Parameterized.Parameters(name = "{1}") public static Iterable constructorFeeder() { return ImmutableList.of( @@ -71,115 +73,123 @@ public static Iterable constructorFeeder() ); } - String periodString; - Granularity expectedGranularity; - - public TimeFloorToGranularityConversionTest(String periodString, Granularity expectedGranularity) - { - this.periodString = periodString; - this.expectedGranularity = expectedGranularity; - } - - @Test - public void testGranularityFromTimeFloor() + @ParameterizedTest(name = "{1}") + @MethodSource("constructorFeeder") + public void testGranularityFromTimeFloor(String periodString, Granularity expectedGranularity) { final SqlNodeList args = new SqlNodeList(SqlParserPos.ZERO); args.add(new SqlIdentifier("__time", SqlParserPos.ZERO)); - args.add(SqlLiteral.createCharString(this.periodString, SqlParserPos.ZERO)); + args.add(SqlLiteral.createCharString(periodString, SqlParserPos.ZERO)); final SqlNode timeFloorCall = TimeFloorOperatorConversion.SQL_FUNCTION.createCall(args); Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity( timeFloorCall); - Assert.assertEquals(expectedGranularity, actualGranularity); + Assertions.assertEquals(expectedGranularity, actualGranularity); } } /** * Sanity checking that FLOOR(__time TO TimeUnit()) works as intended with the supported granularities */ - @RunWith(Parameterized.class) - public static class FloorToGranularityConversionTest + @Nested + public class FloorToGranularityConversionTest { - @Parameterized.Parameters(name = "{1}") - public static Iterable constructorFeeder() - { - return ImmutableList.of( - new Object[]{TimeUnit.SECOND, TimeUnits.toPeriod(TimeUnitRange.SECOND), Granularities.SECOND}, - new Object[]{TimeUnit.MINUTE, TimeUnits.toPeriod(TimeUnitRange.MINUTE), Granularities.MINUTE}, - new Object[]{TimeUnit.HOUR, TimeUnits.toPeriod(TimeUnitRange.HOUR), Granularities.HOUR}, - new Object[]{TimeUnit.DAY, TimeUnits.toPeriod(TimeUnitRange.DAY), Granularities.DAY}, - new Object[]{TimeUnit.WEEK, TimeUnits.toPeriod(TimeUnitRange.WEEK), Granularities.WEEK}, - new Object[]{TimeUnit.MONTH, TimeUnits.toPeriod(TimeUnitRange.MONTH), Granularities.MONTH}, - new Object[]{TimeUnit.QUARTER, TimeUnits.toPeriod(TimeUnitRange.QUARTER), Granularities.QUARTER}, - new Object[]{TimeUnit.YEAR, TimeUnits.toPeriod(TimeUnitRange.YEAR), Granularities.YEAR} + public static Stream timeUnitGranularityFeeder() + { + return Stream.of( + Arguments.of(TimeUnit.SECOND, Granularities.SECOND), + Arguments.of(TimeUnit.MINUTE, Granularities.MINUTE), + Arguments.of(TimeUnit.HOUR, Granularities.HOUR), + Arguments.of(TimeUnit.DAY, Granularities.DAY), + Arguments.of(TimeUnit.WEEK, Granularities.WEEK), + Arguments.of(TimeUnit.MONTH, Granularities.MONTH), + Arguments.of(TimeUnit.QUARTER, Granularities.QUARTER), + Arguments.of(TimeUnit.YEAR, Granularities.YEAR) ); } - TimeUnit timeUnit; - Period period; - Granularity expectedGranularity; - - public FloorToGranularityConversionTest(TimeUnit timeUnit, Period period, Granularity expectedGranularity) + public static Stream periodGranularityFeeder() { - this.timeUnit = timeUnit; - this.period = period; - this.expectedGranularity = expectedGranularity; + return Stream.of( + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.SECOND), Granularities.SECOND), + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.MINUTE), Granularities.MINUTE), + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.HOUR), Granularities.HOUR), + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.DAY), Granularities.DAY), + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.WEEK), Granularities.WEEK), + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.MONTH), Granularities.MONTH), + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.QUARTER), Granularities.QUARTER), + Arguments.of(TimeUnits.toPeriod(TimeUnitRange.YEAR), Granularities.YEAR) + ); } - @Test - public void testGetGranularityFromFloor() + @ParameterizedTest(name = "{0}") + @MethodSource("timeUnitGranularityFeeder") + public void testGetGranularityFromFloor(TimeUnit timeUnit, Granularity expectedGranularity) { // parserPos doesn't matter final SqlNodeList args = new SqlNodeList(SqlParserPos.ZERO); args.add(new SqlIdentifier("__time", SqlParserPos.ZERO)); - args.add(new SqlIntervalQualifier(this.timeUnit, null, SqlParserPos.ZERO)); + args.add(new SqlIntervalQualifier(timeUnit, null, SqlParserPos.ZERO)); final SqlNode floorCall = SqlStdOperatorTable.FLOOR.createCall(args); Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(floorCall); - Assert.assertEquals(expectedGranularity, actualGranularity); + Assertions.assertEquals(expectedGranularity, actualGranularity); } /** * Tests clause like "PARTITIONED BY 'day'" */ - @Test - public void testConvertSqlNodeToGranularityAsLiteral() + @ParameterizedTest(name = "{0}") + @MethodSource("timeUnitGranularityFeeder") + public void testConvertSqlNodeToGranularityAsLiteral( + TimeUnit timeUnit, + Granularity expectedGranularity + ) { SqlNode sqlNode = SqlLiteral.createCharString(timeUnit.name(), SqlParserPos.ZERO); Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode); - Assert.assertEquals(expectedGranularity, actualGranularity); + Assertions.assertEquals(expectedGranularity, actualGranularity); } /** * Tests clause like "PARTITIONED BY PT1D" */ - @Test - public void testConvertSqlNodeToPeriodFormGranularityAsIdentifier() + @ParameterizedTest(name = "{0}") + @MethodSource("periodGranularityFeeder") + public void testConvertSqlNodeToPeriodFormGranularityAsIdentifier( + Period period, + Granularity expectedGranularity + ) { SqlNode sqlNode = new SqlIdentifier(period.toString(), SqlParserPos.ZERO); Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode); - Assert.assertEquals(expectedGranularity, actualGranularity); + Assertions.assertEquals(expectedGranularity, actualGranularity); } /** * Tests clause like "PARTITIONED BY 'PT1D'" */ - @Test - public void testConvertSqlNodeToPeriodFormGranularityAsLiteral() + @ParameterizedTest(name = "{0}") + @MethodSource("periodGranularityFeeder") + public void testConvertSqlNodeToPeriodFormGranularityAsLiteral( + Period period, + Granularity expectedGranularity + ) { SqlNode sqlNode = SqlLiteral.createCharString(period.toString(), SqlParserPos.ZERO); Granularity actualGranularity = DruidSqlParserUtils.convertSqlNodeToGranularity(sqlNode); - Assert.assertEquals(expectedGranularity, actualGranularity); + Assertions.assertEquals(expectedGranularity, actualGranularity); } } /** * Test class that validates the resolution of "CLUSTERED BY" columns to output columns. */ - public static class ResolveClusteredByColumnsTest + @Nested + public class ResolveClusteredByColumnsTest { @Test public void testNullClusteredByAndSource() { - Assert.assertNull(DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(null, null)); + Assertions.assertNull(DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(null, null)); } @Test @@ -191,7 +201,7 @@ public void testNullClusteredBy() .add(3, "bar") .build(); - Assert.assertNull( + Assertions.assertNull( DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns( null, fields @@ -214,7 +224,7 @@ public void testSimpledClusteredByWithNullSource() new SqlParserPos(0, 3) ); args.add(sqlBasicCall1); - Assert.assertEquals( + Assertions.assertEquals( Arrays.asList("__time", "FOO", "DIM3_ALIAS"), DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(args, null) ); @@ -234,7 +244,7 @@ public void testSimpleClusteredBy() clusteredByArgs.add(new SqlIdentifier("FOO", SqlParserPos.ZERO)); clusteredByArgs.add(SqlLiteral.createExactNumeric("3", SqlParserPos.ZERO)); - Assert.assertEquals( + Assertions.assertEquals( Arrays.asList("__time", "FOO", "BOO"), DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(clusteredByArgs, sourceFieldMappings) ); @@ -261,14 +271,15 @@ public void testClusteredByOrdinalsAndAliases() clusteredByArgs.add(SqlLiteral.createExactNumeric("5", SqlParserPos.ZERO)); clusteredByArgs.add(SqlLiteral.createExactNumeric("7", SqlParserPos.ZERO)); - Assert.assertEquals( + Assertions.assertEquals( Arrays.asList("DIM3_ALIAS", "floor_dim4_time", "DIM5", "TIME_FLOOR(\"timestamps\", 'PT1H')"), DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(clusteredByArgs, sourceFieldMappings) ); } } - public static class ClusteredByColumnsValidationTest + @Nested + public class ClusteredByColumnsValidationTest { /** * Tests an empty CLUSTERED BY clause @@ -340,7 +351,8 @@ public void testClusteredByColumnsWithNegativeOrdinalThrowsException() } } - public static class FloorToGranularityConversionErrorsTest + @Nested + public class FloorToGranularityConversionErrorsTest { /** * Tests clause like "PARTITIONED BY CEIL(__time TO DAY)" @@ -453,7 +465,8 @@ public void testConvertSqlNodeToGranularityWithIncorrectIngestionGranularityInTi } } - public static class NonParameterizedTests + @Nested + public class NonParameterizedTests { private static final DateTimeZone TZ_LOS_ANGELES = DateTimes.inferTzFromString("America/Los_Angeles"); @@ -472,7 +485,7 @@ public void test_parseTimeStampWithTimeZone_timestamp_utc() DateTimeZone.UTC ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test @@ -490,7 +503,7 @@ public void test_parseTimeStampWithTimeZone_timestamp_losAngeles() TZ_LOS_ANGELES ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test @@ -508,7 +521,7 @@ public void test_parseTimeStampWithTimeZone_timestampWithLocalTimeZone() DateTimeZone.UTC ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test @@ -526,7 +539,7 @@ public void test_parseTimeStampWithTimeZone_timestampWithLocalTimeZone_losAngele TZ_LOS_ANGELES ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test @@ -543,7 +556,7 @@ public void test_parseTimeStampWithTimeZone_unknownTimestamp() DateTimeZone.UTC ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test @@ -560,7 +573,7 @@ public void test_parseTimeStampWithTimeZone_unknownTimestampWithLocalTimeZone() DateTimeZone.UTC ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test @@ -577,7 +590,7 @@ public void test_parseTimeStampWithTimeZone_unknownTimestamp_losAngeles() TZ_LOS_ANGELES ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test @@ -594,13 +607,13 @@ public void test_parseTimeStampWithTimeZone_unknownTimestampWithLocalTimeZone_lo TZ_LOS_ANGELES ); - Assert.assertEquals(String.valueOf(ts.getMillis()), s); + Assertions.assertEquals(String.valueOf(ts.getMillis()), s); } @Test public void test_parseTimeStampWithTimeZone_unknownTimestamp_invalid() { - final DruidException e = Assert.assertThrows( + final DruidException e = Assertions.assertThrows( DruidException.class, () -> DruidSqlParserUtils.parseTimeStampWithTimeZone( SqlLiteral.createUnknown( diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java index 0e843b4ca2ea..a43b0ee85f71 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlUnparseTest.java @@ -23,11 +23,11 @@ import org.apache.calcite.sql.SqlWriter; import org.apache.calcite.sql.dialect.CalciteSqlDialect; import org.apache.calcite.sql.pretty.SqlPrettyWriter; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.io.StringReader; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; /** * A class containing unit tests for testing implementations of {@link org.apache.calcite.sql.SqlNode#unparse(SqlWriter, int, int)} diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java index c283a364d1af..ee5a5b718f2e 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/CalcitePlannerModuleTest.java @@ -54,13 +54,14 @@ import org.easymock.EasyMock; import org.easymock.EasyMockExtension; import org.easymock.Mock; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import javax.validation.Validation; import javax.validation.Validator; + import java.util.Collections; import java.util.Optional; import java.util.Set; @@ -154,29 +155,29 @@ public void onMatch(RelOptRuleCall call) public void testDruidOperatorTableIsInjectable() { DruidOperatorTable operatorTable = injector.getInstance(DruidOperatorTable.class); - Assert.assertNotNull(operatorTable); + Assertions.assertNotNull(operatorTable); // Should be a singleton. DruidOperatorTable other = injector.getInstance(DruidOperatorTable.class); - Assert.assertSame(other, operatorTable); + Assertions.assertSame(other, operatorTable); } @Test public void testPlannerFactoryIsInjectable() { PlannerFactory plannerFactory = injector.getInstance(PlannerFactory.class); - Assert.assertNotNull(PlannerFactory.class); + Assertions.assertNotNull(PlannerFactory.class); // Should be a singleton. PlannerFactory other = injector.getInstance(PlannerFactory.class); - Assert.assertSame(other, plannerFactory); + Assertions.assertSame(other, plannerFactory); } @Test public void testPlannerConfigIsInjected() { PlannerConfig plannerConfig = injector.getInstance(PlannerConfig.class); - Assert.assertNotNull(plannerConfig); + Assertions.assertNotNull(plannerConfig); } @Test @@ -199,7 +200,7 @@ public void testExtensionCalciteRule() boolean containsCustomRule = injector.getInstance(CalciteRulesManager.class) .druidConventionRuleSet(context) .contains(customRule); - Assert.assertTrue(containsCustomRule); + Assertions.assertTrue(containsCustomRule); } @Test @@ -239,6 +240,6 @@ private void assertBloat(PlannerContext context, int expectedBloat) .filter(rule -> rule instanceof ProjectMergeRule) .map(rule -> (ProjectMergeRule) rule) .findAny(); - Assert.assertTrue(firstProjectMergeRule.isPresent() && firstProjectMergeRule.get().config.bloat() == expectedBloat); + Assertions.assertTrue(firstProjectMergeRule.isPresent() && firstProjectMergeRule.get().config.bloat() == expectedBloat); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java index a534b81aa063..1bb9e42dbf29 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingTest.java @@ -20,7 +20,7 @@ package org.apache.druid.sql.calcite.planner; import nl.jqno.equalsverifier.EqualsVerifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class ColumnMappingTest { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java index 9ff62b4f16bc..4ac524ab82b8 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/ColumnMappingsTest.java @@ -20,7 +20,7 @@ package org.apache.druid.sql.calcite.planner; import nl.jqno.equalsverifier.EqualsVerifier; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class ColumnMappingsTest { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java index bada2ace92c9..cfdc598276c3 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidHintTest.java @@ -20,19 +20,19 @@ package org.apache.druid.sql.calcite.planner; import org.apache.druid.query.JoinAlgorithm; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; public class DruidHintTest { @Test public void testFromString() { - Assert.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").id(), DruidHint.DruidJoinHint.SortMergeJoinHint.SORT_MERGE_JOIN); - Assert.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").id(), DruidHint.DruidJoinHint.BroadcastJoinHint.BROADCAST_JOIN); - Assert.assertNull(DruidHint.DruidJoinHint.fromString("hash")); + Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").id(), DruidHint.DruidJoinHint.SortMergeJoinHint.SORT_MERGE_JOIN); + Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").id(), DruidHint.DruidJoinHint.BroadcastJoinHint.BROADCAST_JOIN); + Assertions.assertNull(DruidHint.DruidJoinHint.fromString("hash")); - Assert.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").asJoinAlgorithm(), JoinAlgorithm.SORT_MERGE); - Assert.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").asJoinAlgorithm(), JoinAlgorithm.BROADCAST); + Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("sort_merge").asJoinAlgorithm(), JoinAlgorithm.SORT_MERGE); + Assertions.assertEquals(DruidHint.DruidJoinHint.fromString("broadcast").asJoinAlgorithm(), JoinAlgorithm.BROADCAST); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java index f2a66e46e8f7..a2490f71878c 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidOperatorTableTest.java @@ -31,15 +31,15 @@ import org.apache.druid.sql.calcite.expression.SqlOperatorConversion; import org.apache.druid.sql.calcite.rel.Windowing; import org.apache.druid.sql.calcite.table.RowSignatures; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.stream.Collectors; -import static org.junit.Assert.assertFalse; +import static org.junit.jupiter.api.Assertions.assertFalse; public class DruidOperatorTableTest { @@ -48,22 +48,22 @@ public void testBuiltInOperatorTable() { DruidOperatorTable operatorTable = new DruidOperatorTable(ImmutableSet.of(), ImmutableSet.of()); List operatorList = operatorTable.getOperatorList(); - Assert.assertNotNull(operatorList); - Assert.assertTrue("Built-in operators should be loaded by default", operatorList.size() > 0); + Assertions.assertNotNull(operatorList); + Assertions.assertTrue(operatorList.size() > 0, "Built-in operators should be loaded by default"); } @Test public void testIsFunctionSyntax() { - Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION)); - Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_STAR)); - Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_ID)); - Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.SPECIAL)); - Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.INTERNAL)); + Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION)); + Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_STAR)); + Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.FUNCTION_ID)); + Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.SPECIAL)); + Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(SqlSyntax.INTERNAL)); - Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.BINARY)); - Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.PREFIX)); - Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.POSTFIX)); + Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.BINARY)); + Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.PREFIX)); + Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(SqlSyntax.POSTFIX)); } @Test @@ -91,15 +91,15 @@ public void testCustomOperatorTable() DruidOperatorTable operatorTable = new DruidOperatorTable(ImmutableSet.of(), extractionOperators); List operatorList = operatorTable.getOperatorList(); - Assert.assertNotNull(operatorList); - Assert.assertTrue("We should have at least two operators -- the ones we loaded above plus the built-in" - + " operators that gets loaded by default", operatorList.size() > 2); + Assertions.assertNotNull(operatorList); + Assertions.assertTrue(operatorList.size() > 2, "We should have at least two operators -- the ones we loaded above plus the built-in" + + " operators that gets loaded by default"); - Assert.assertTrue(operatorList.contains(operator1)); - Assert.assertTrue(operatorList.contains(operator2)); + Assertions.assertTrue(operatorList.contains(operator1)); + Assertions.assertTrue(operatorList.contains(operator2)); - Assert.assertTrue(DruidOperatorTable.isFunctionSyntax(operator1.getSyntax())); - Assert.assertFalse(DruidOperatorTable.isFunctionSyntax(operator2.getSyntax())); + Assertions.assertTrue(DruidOperatorTable.isFunctionSyntax(operator1.getSyntax())); + Assertions.assertFalse(DruidOperatorTable.isFunctionSyntax(operator2.getSyntax())); } @Test @@ -118,8 +118,8 @@ public void testBuiltinWindowOperatorsSupportFramingAsExpected() continue; default: assertFalse( - operator + " allows framing; should be supported or rejected and then exclude from this check", - operator.allowsFraming() + operator.allowsFraming(), + operator + " allows framing; should be supported or rejected and then exclude from this check" ); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java index f58340d2b894..2f387bdc125d 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/DruidRexExecutorTest.java @@ -61,8 +61,8 @@ import org.apache.druid.testing.InitializedNullHandlingTest; import org.easymock.EasyMock; import org.joda.time.DateTimeZone; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.math.BigDecimal; import java.util.ArrayList; @@ -141,9 +141,9 @@ public void testLongsReduced() DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT); List reduced = new ArrayList<>(); rexy.reduce(rexBuilder, ImmutableList.of(call), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); - Assert.assertEquals(new BigDecimal(30L), ((RexLiteral) reduced.get(0)).getValue()); + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); + Assertions.assertEquals(new BigDecimal(30L), ((RexLiteral) reduced.get(0)).getValue()); } @Test @@ -159,9 +159,9 @@ public void testCastDateReduced() DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT); List reduced = new ArrayList<>(); rexy.reduce(rexBuilder, ImmutableList.of(call), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); - Assert.assertEquals( + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); + Assertions.assertEquals( rexBuilder.makeDateLiteral( Calcites.jodaToCalciteDateString( DateTimes.of("2010-01-01"), @@ -184,9 +184,9 @@ public void testTimeParseReduced() DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT); List reduced = new ArrayList<>(); rexy.reduce(rexBuilder, ImmutableList.of(call), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); - Assert.assertEquals( + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); + Assertions.assertEquals( Calcites.jodaToCalciteTimestampLiteral( rexBuilder, DateTimes.of("2010-01-01T02:03:04Z"), @@ -209,9 +209,9 @@ public void testTimeParseUnparseableReduced() DruidRexExecutor rexy = new DruidRexExecutor(PLANNER_CONTEXT); List reduced = new ArrayList<>(); rexy.reduce(rexBuilder, ImmutableList.of(call), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); - Assert.assertTrue(RexLiteral.isNullLiteral(reduced.get(0))); + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals(SqlKind.LITERAL, reduced.get(0).getKind()); + Assertions.assertTrue(RexLiteral.isNullLiteral(reduced.get(0))); } @Test @@ -221,9 +221,9 @@ public void testComplexNotReduced() RexNode call = rexBuilder.makeCall(OPERATOR); List reduced = new ArrayList<>(); rexy.reduce(rexBuilder, ImmutableList.of(call), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind()); - Assert.assertEquals( + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind()); + Assertions.assertEquals( CalciteTestBase.makeExpression(ColumnType.ofComplex("hyperUnique"), "hyper_unique()"), Expressions.toDruidExpression( PLANNER_CONTEXT, @@ -243,8 +243,8 @@ public void testArrayOfDoublesReduction() List elements = ImmutableList.of(BigDecimal.valueOf(50.12), BigDecimal.valueOf(12.1)); RexNode literal = rexBuilder.makeLiteral(elements, arraySqlType, true); rexy.reduce(rexBuilder, ImmutableList.of(literal), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals( + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals( DruidExpression.ofExpression( ColumnType.DOUBLE_ARRAY, DruidExpression.functionCall("array"), @@ -271,8 +271,8 @@ public void testArrayOfLongsReduction() List elements = ImmutableList.of(BigDecimal.valueOf(50), BigDecimal.valueOf(12)); RexNode literal = rexBuilder.makeLiteral(elements, arraySqlType, true); rexy.reduce(rexBuilder, ImmutableList.of(literal), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals( + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals( DruidExpression.ofExpression( ColumnType.LONG_ARRAY, DruidExpression.functionCall("array"), @@ -300,9 +300,9 @@ public void testMultiValueStringNotReduced() ); List reduced = new ArrayList<>(); rexy.reduce(rexBuilder, ImmutableList.of(call), reduced); - Assert.assertEquals(1, reduced.size()); - Assert.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind()); - Assert.assertEquals( + Assertions.assertEquals(1, reduced.size()); + Assertions.assertEquals(SqlKind.OTHER_FUNCTION, reduced.get(0).getKind()); + Assertions.assertEquals( DruidExpression.ofExpression( ColumnType.STRING, DruidExpression.functionCall("string_to_array"), diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java index c54e46a14dda..f209fc437ae0 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/OffsetLimitTest.java @@ -21,8 +21,8 @@ import com.google.common.collect.ImmutableList; import org.apache.druid.java.util.common.StringUtils; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.List; import java.util.stream.Collectors; @@ -42,14 +42,7 @@ public void testAndThen() final OffsetLimit outer = new OffsetLimit(outerOffset, outerLimit < 0 ? null : (long) outerLimit); final OffsetLimit combined = inner.andThen(outer); - Assert.assertEquals( - StringUtils.format( - "innerOffset[%s], innerLimit[%s], outerOffset[%s], outerLimit[%s]", - innerOffset, - innerLimit, - outerOffset, - outerLimit - ), + Assertions.assertEquals( things.stream() .skip(innerOffset) .limit(innerLimit < 0 ? Long.MAX_VALUE : innerLimit) @@ -59,7 +52,14 @@ public void testAndThen() things.stream() .skip(combined.getOffset()) .limit(combined.hasLimit() ? combined.getLimit() : Long.MAX_VALUE) - .collect(Collectors.toList()) + .collect(Collectors.toList()), + StringUtils.format( + "innerOffset[%s], innerLimit[%s], outerOffset[%s], outerLimit[%s]", + innerOffset, + innerLimit, + outerOffset, + outerLimit + ) ); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java index c622f279325c..6b3442132aa6 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/PlannerConfigTest.java @@ -21,8 +21,8 @@ import nl.jqno.equalsverifier.EqualsVerifier; import nl.jqno.equalsverifier.Warning; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; public class PlannerConfigTest { @@ -30,9 +30,9 @@ public class PlannerConfigTest public void testPlannerConfigDefaults() { PlannerConfig config = new PlannerConfig(); - Assert.assertFalse(config.isUseLexicographicTopN()); - Assert.assertTrue(config.isUseApproximateTopN()); - Assert.assertTrue(config.isUseApproximateCountDistinct()); + Assertions.assertFalse(config.isUseLexicographicTopN()); + Assertions.assertTrue(config.isUseApproximateTopN()); + Assertions.assertTrue(config.isUseApproximateCountDistinct()); } @Test @@ -41,8 +41,8 @@ public void testPlannerConfigBuilder() PlannerConfig config = PlannerConfig.builder() .useLexicographicTopN(true) .build(); - Assert.assertTrue(config.isUseLexicographicTopN()); - Assert.assertTrue(config.isUseApproximateTopN()); + Assertions.assertTrue(config.isUseLexicographicTopN()); + Assertions.assertTrue(config.isUseApproximateTopN()); } @Test @@ -52,8 +52,8 @@ public void testPlannerConfigBuilderBothTopNFlagsDisabled() .useLexicographicTopN(false) .useApproximateTopN(false) .build(); - Assert.assertFalse(config.isUseLexicographicTopN()); - Assert.assertFalse(config.isUseApproximateTopN()); + Assertions.assertFalse(config.isUseLexicographicTopN()); + Assertions.assertFalse(config.isUseApproximateTopN()); } @Test diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java index 613aebfcdfd1..d821905315c3 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/planner/TrivialTest.java @@ -27,8 +27,8 @@ import java.util.Collections; import java.util.Set; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; /** * Test class to reference items that are otherwise unused in this package, and diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java index 70d76d4c7537..95c95757180d 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidQueryTest.java @@ -38,8 +38,8 @@ import org.apache.druid.sql.calcite.planner.ExpressionParserImpl; import org.apache.druid.sql.calcite.util.CalciteTests; import org.joda.time.Interval; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.Collections; @@ -221,8 +221,8 @@ private void verify( Interval interval ) { - Assert.assertEquals(dataSource, pair.lhs); - Assert.assertEquals("dim-filter: " + pair.rhs.getDimFilter(), columnFilter, pair.rhs.getDimFilter()); - Assert.assertEquals(Collections.singletonList(interval), pair.rhs.getIntervals()); + Assertions.assertEquals(dataSource, pair.lhs); + Assertions.assertEquals(columnFilter, pair.rhs.getDimFilter(), "dim-filter: " + pair.rhs.getDimFilter()); + Assertions.assertEquals(Collections.singletonList(interval), pair.rhs.getIntervals()); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java index 61dcd59ea1d4..f342d844acca 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelTest.java @@ -68,9 +68,9 @@ import org.apache.druid.sql.calcite.table.DatasourceTable; import org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata; import org.apache.druid.sql.calcite.table.DruidTable; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; @@ -118,7 +118,7 @@ public class DruidRelTest private PlannerContext mockPlannerContext; private DruidQueryRel druidQueryRelNode; - @Before + @BeforeEach public void setup() throws Exception { MockitoAnnotations.openMocks(this); @@ -154,9 +154,9 @@ public void testDruidQueryRel() DruidQuery query = druidQueryRelNode.toDruidQuery(true); // explain query should return a TableDataSource. - Assert.assertEquals(TABLE, queryForExplaining.getDataSource()); + Assertions.assertEquals(TABLE, queryForExplaining.getDataSource()); // query should return a RestrictedDataSource. - Assert.assertEquals(RESTRICTED, query.getDataSource()); + Assertions.assertEquals(RESTRICTED, query.getDataSource()); } @Test @@ -180,10 +180,10 @@ public void testDruidJoinQueryRel() DruidQuery query = joinRel.toDruidQuery(false); // Assert - Assert.assertEquals(DruidJoinQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); + Assertions.assertEquals(DruidJoinQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); JoinDataSource dataSource = (JoinDataSource) query.getDataSource(); - Assert.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getLeft()).getQuery().getDataSource()); - Assert.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getRight()).getQuery().getDataSource()); + Assertions.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getLeft()).getQuery().getDataSource()); + Assertions.assertEquals(RESTRICTED, ((QueryDataSource) dataSource.getRight()).getQuery().getDataSource()); } @Test @@ -204,8 +204,8 @@ public void testDruidUnionQueryRel() DruidQuery query = rel.toDruidQuery(false); // Assert - Assert.assertEquals(DruidUnionDataSourceRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); - Assert.assertEquals(new UnionDataSource(ImmutableList.of(RESTRICTED, RESTRICTED)), query.getDataSource()); + Assertions.assertEquals(DruidUnionDataSourceRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); + Assertions.assertEquals(new UnionDataSource(ImmutableList.of(RESTRICTED, RESTRICTED)), query.getDataSource()); } @Test @@ -225,8 +225,8 @@ public void testDruidOuterQueryRel() DruidQuery query = rel.toDruidQuery(false); // Assert - Assert.assertEquals(DruidOuterQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); - Assert.assertEquals(RESTRICTED, ((QueryDataSource) query.getDataSource()).getQuery().getDataSource()); + Assertions.assertEquals(DruidOuterQueryRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); + Assertions.assertEquals(RESTRICTED, ((QueryDataSource) query.getDataSource()).getQuery().getDataSource()); } @Test @@ -253,8 +253,8 @@ public void testDruidCorrelateUnnestRel() DruidQuery query = rel.toDruidQuery(false); // Assert - Assert.assertEquals(DruidCorrelateUnnestRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); - Assert.assertEquals(RESTRICTED, ((UnnestDataSource) query.getDataSource()).getBase()); + Assertions.assertEquals(DruidCorrelateUnnestRel.DUMMY_DATA_SOURCE, queryForExplaining.getDataSource()); + Assertions.assertEquals(RESTRICTED, ((UnnestDataSource) query.getDataSource()).getBase()); } @Test @@ -262,10 +262,10 @@ public void testDruidUnnestRel() { DruidUnnestRel rel = DruidUnnestRel.create(mockRelOptCluster, mockRelTraitSet, ALWAYS_TRUE, mockPlannerContext); - CannotBuildQueryException e1 = Assert.assertThrows(CannotBuildQueryException.class, rel::toDruidQueryForExplaining); - CannotBuildQueryException e2 = Assert.assertThrows(CannotBuildQueryException.class, () -> rel.toDruidQuery(false)); - Assert.assertEquals("Cannot execute UNNEST directly", e1.getMessage()); - Assert.assertEquals("Cannot execute UNNEST directly", e2.getMessage()); + CannotBuildQueryException e1 = Assertions.assertThrows(CannotBuildQueryException.class, rel::toDruidQueryForExplaining); + CannotBuildQueryException e2 = Assertions.assertThrows(CannotBuildQueryException.class, () -> rel.toDruidQuery(false)); + Assertions.assertEquals("Cannot execute UNNEST directly", e1.getMessage()); + Assertions.assertEquals("Cannot execute UNNEST directly", e2.getMessage()); } @Test @@ -273,11 +273,11 @@ public void testDruidUnionRel() { DruidUnionRel rel = DruidUnionRel.create(mockPlannerContext, REC_TYPE, ImmutableList.of(druidQueryRelNode), 1000); - UnsupportedOperationException e1 = Assert.assertThrows( + UnsupportedOperationException e1 = Assertions.assertThrows( UnsupportedOperationException.class, rel::toDruidQueryForExplaining ); - UnsupportedOperationException e2 = Assert.assertThrows( + UnsupportedOperationException e2 = Assertions.assertThrows( UnsupportedOperationException.class, () -> rel.toDruidQuery(false) ); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java index e5daa3471e16..bf0561cda4df 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/DruidRelsTest.java @@ -28,10 +28,11 @@ import org.apache.calcite.util.mapping.Mappings; import org.apache.druid.sql.calcite.table.DruidTable; import org.easymock.EasyMock; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import javax.annotation.Nullable; + import java.util.List; import java.util.function.Consumer; @@ -41,8 +42,8 @@ public class DruidRelsTest public void test_isScanOrMapping_scan() { final DruidRel rel = mockDruidRel(DruidQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, true)); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery()); } @@ -50,8 +51,8 @@ public void test_isScanOrMapping_scan() public void test_isScanOrMapping_scanJoin() { final DruidRel rel = mockDruidRel(DruidJoinQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery()); } @@ -59,8 +60,8 @@ public void test_isScanOrMapping_scanJoin() public void test_isScanOrMapping_scanUnion() { final DruidRel rel = mockDruidRel(DruidUnionDataSourceRel.class, PartialDruidQuery.Stage.SCAN, null, null, null); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery()); } @@ -68,8 +69,8 @@ public void test_isScanOrMapping_scanUnion() public void test_isScanOrMapping_scanQuery() { final DruidRel rel = mockDruidRel(DruidOuterQueryRel.class, PartialDruidQuery.Stage.SCAN, null, null, null); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery()); } @@ -84,8 +85,8 @@ public void test_isScanOrMapping_mapping() project, null ); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, true)); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -101,8 +102,8 @@ public void test_isScanOrMapping_mappingJoin() project, null ); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -118,8 +119,8 @@ public void test_isScanOrMapping_mappingUnion() project, null ); - Assert.assertTrue(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertTrue(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -135,8 +136,8 @@ public void test_isScanOrMapping_mappingQuery() project, null ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -152,8 +153,8 @@ public void test_isScanOrMapping_nonMapping() project, null ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -169,8 +170,8 @@ public void test_isScanOrMapping_nonMappingJoin() project, null ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -186,8 +187,8 @@ public void test_isScanOrMapping_nonMappingUnion() project, null ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -203,8 +204,8 @@ public void test_isScanOrMapping_filterThenProject() project, mockFilter() ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -220,8 +221,8 @@ public void test_isScanOrMapping_filterThenProjectJoin() project, mockFilter() ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -237,8 +238,8 @@ public void test_isScanOrMapping_filterThenProjectUnion() project, mockFilter() ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } @@ -253,8 +254,8 @@ public void test_isScanOrMapping_filter() null, mockFilter() ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery()); } @@ -269,8 +270,8 @@ public void test_isScanOrMapping_filterJoin() null, mockFilter() ); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, true)); - Assert.assertFalse(DruidRels.isScanOrMapping(rel, false)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, true)); + Assertions.assertFalse(DruidRels.isScanOrMapping(rel, false)); EasyMock.verify(rel, rel.getPartialDruidQuery()); } @@ -293,8 +294,8 @@ public void test_isScanOrMapping_allStages() null ); - Assert.assertEquals(stage.toString(), okStages.contains(stage), DruidRels.isScanOrMapping(rel, true)); - Assert.assertEquals(stage.toString(), okStages.contains(stage), DruidRels.isScanOrMapping(rel, false)); + Assertions.assertEquals(okStages.contains(stage), DruidRels.isScanOrMapping(rel, true), stage.toString()); + Assertions.assertEquals(okStages.contains(stage), DruidRels.isScanOrMapping(rel, false), stage.toString()); EasyMock.verify(rel, rel.getPartialDruidQuery(), project); } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java index eb4d64b45371..1fed28711405 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rel/GroupingTest.java @@ -24,7 +24,7 @@ import org.apache.druid.java.util.common.StringUtils; import org.apache.druid.segment.column.ColumnType; import org.apache.druid.sql.calcite.expression.DruidExpression; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class GroupingTest { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java index c4312b0ae25c..1546e5b98d1e 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidJoinRuleTest.java @@ -34,9 +34,9 @@ import org.apache.druid.query.QueryContext; import org.apache.druid.sql.calcite.planner.DruidTypeSystem; import org.apache.druid.sql.calcite.planner.PlannerContext; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; import java.math.BigDecimal; @@ -66,7 +66,7 @@ public class DruidJoinRuleTest private DruidJoinRule druidJoinRule; - @Before + @BeforeEach public void setup() { PlannerContext plannerContext = Mockito.mock(PlannerContext.class); @@ -78,7 +78,7 @@ public void setup() @Test public void test_canHandleCondition_leftEqRight() { - Assert.assertTrue( + Assertions.assertTrue( druidJoinRule.canHandleCondition( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, @@ -97,7 +97,7 @@ public void test_canHandleCondition_leftEqRight() @Test public void test_canHandleCondition_leftFnEqRight() { - Assert.assertTrue( + Assertions.assertTrue( druidJoinRule.canHandleCondition( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, @@ -120,7 +120,7 @@ public void test_canHandleCondition_leftFnEqRight() @Test public void test_canHandleCondition_leftEqRightFn() { - Assert.assertTrue( + Assertions.assertTrue( druidJoinRule.canHandleCondition( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, @@ -144,7 +144,7 @@ public void test_canHandleCondition_leftEqRightFn() public void test_canHandleCondition_leftEqLeft() { - Assert.assertTrue( + Assertions.assertTrue( druidJoinRule.canHandleCondition( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, @@ -163,7 +163,7 @@ public void test_canHandleCondition_leftEqLeft() @Test public void test_canHandleCondition_rightEqRight() { - Assert.assertTrue( + Assertions.assertTrue( druidJoinRule.canHandleCondition( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, @@ -182,7 +182,7 @@ public void test_canHandleCondition_rightEqRight() @Test public void test_canHandleCondition_leftEqRightFn_leftJoin() { - Assert.assertFalse( + Assertions.assertFalse( druidJoinRule.canHandleCondition( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, @@ -205,7 +205,7 @@ public void test_canHandleCondition_leftEqRightFn_leftJoin() @Test public void test_canHandleCondition_leftEqRightFn_systemFields() { - Assert.assertFalse( + Assertions.assertFalse( druidJoinRule.canHandleCondition( rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, @@ -228,7 +228,7 @@ public void test_canHandleCondition_leftEqRightFn_systemFields() @Test public void test_canHandleCondition_true() { - Assert.assertTrue( + Assertions.assertTrue( druidJoinRule.canHandleCondition( rexBuilder.makeLiteral(true), leftType, @@ -243,7 +243,7 @@ public void test_canHandleCondition_true() @Test public void test_canHandleCondition_false() { - Assert.assertTrue( + Assertions.assertTrue( druidJoinRule.canHandleCondition( rexBuilder.makeLiteral(false), leftType, @@ -260,8 +260,8 @@ public void test_decomposeAnd_notAnAnd() { final List rexNodes = DruidJoinRule.decomposeAnd(rexBuilder.makeInputRef(leftType, 0)); - Assert.assertEquals(1, rexNodes.size()); - Assert.assertEquals(rexBuilder.makeInputRef(leftType, 0), Iterables.getOnlyElement(rexNodes)); + Assertions.assertEquals(1, rexNodes.size()); + Assertions.assertEquals(rexBuilder.makeInputRef(leftType, 0), Iterables.getOnlyElement(rexNodes)); } @Test @@ -283,7 +283,7 @@ public void test_decomposeAnd_basic() ) ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( rexBuilder.makeExactLiteral(BigDecimal.valueOf(1)), rexBuilder.makeExactLiteral(BigDecimal.valueOf(2)), diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java index 54619b5b10bd..13d9682adfaa 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidLogicalValuesRuleTest.java @@ -36,14 +36,13 @@ import org.apache.druid.testing.InitializedNullHandlingTest; import org.joda.time.DateTime; import org.joda.time.DateTimeZone; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.ExpectedException; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.Mockito; import java.math.BigDecimal; @@ -52,10 +51,9 @@ public class DruidLogicalValuesRuleTest { private static final PlannerContext DEFAULT_CONTEXT = Mockito.mock(PlannerContext.class); - @RunWith(Parameterized.class) - public static class GetValueFromLiteralSimpleTypesTest extends InitializedNullHandlingTest + @Nested + public class GetValueFromLiteralSimpleTypesTest extends InitializedNullHandlingTest { - @Parameters(name = "{1}, {2}") public static Iterable constructorFeeder() { return ImmutableList.of( @@ -71,24 +69,14 @@ public static Iterable constructorFeeder() ); } - private final Comparable val; - private final SqlTypeName sqlTypeName; - private final Class javaType; - - public GetValueFromLiteralSimpleTypesTest(Comparable val, SqlTypeName sqlTypeName, Class javaType) - { - this.val = val; - this.sqlTypeName = sqlTypeName; - this.javaType = javaType; - } - - @Test - public void testGetValueFromLiteral() + @ParameterizedTest(name = "{1}, {2}") + @MethodSource("constructorFeeder") + public void testGetValueFromLiteral(Comparable val, SqlTypeName sqlTypeName, Class javaType) { final RexLiteral literal = Mockito.spy(makeLiteral(val, sqlTypeName, javaType)); final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); - Assert.assertSame(javaType, fromLiteral.getClass()); - Assert.assertEquals(val, fromLiteral); + Assertions.assertSame(javaType, fromLiteral.getClass()); + Assertions.assertEquals(val, fromLiteral); Mockito.verify(literal, Mockito.times(1)).getType(); } @@ -106,18 +94,17 @@ private static RexLiteral makeLiteral(Comparable val, SqlTypeName typeName, C } } - public static class GetValueFromLiteralOtherTypesTest + @Nested + @TestInstance(TestInstance.Lifecycle.PER_CLASS) + public class GetValueFromLiteralOtherTypesTest { private static final PlannerContext DEFAULT_CONTEXT = Mockito.mock(PlannerContext.class); private static final DateTimeZone TIME_ZONE = DateTimes.inferTzFromString("Asia/Seoul"); private static final RelDataTypeFactory TYPE_FACTORY = new SqlTypeFactoryImpl(DruidTypeSystem.INSTANCE); private static final RexBuilder REX_BUILDER = new RexBuilder(TYPE_FACTORY); - @Rule - public ExpectedException expectedException = ExpectedException.none(); - - @BeforeClass - public static void setup() + @BeforeAll + public void setup() { Mockito.when(DEFAULT_CONTEXT.getTimeZone()).thenReturn(TIME_ZONE); } @@ -128,8 +115,8 @@ public void testGetValueFromTrueLiteral() RexLiteral literal = REX_BUILDER.makeLiteral(true); final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); - Assert.assertSame(Long.class, fromLiteral.getClass()); - Assert.assertEquals(1L, fromLiteral); + Assertions.assertSame(Long.class, fromLiteral.getClass()); + Assertions.assertEquals(1L, fromLiteral); } @Test @@ -138,8 +125,8 @@ public void testGetValueFromFalseLiteral() RexLiteral literal = REX_BUILDER.makeLiteral(false); final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); - Assert.assertSame(Long.class, fromLiteral.getClass()); - Assert.assertEquals(0L, fromLiteral); + Assertions.assertSame(Long.class, fromLiteral.getClass()); + Assertions.assertEquals(0L, fromLiteral); } @Test @@ -148,7 +135,7 @@ public void testGetValueFromNullBooleanLiteral() RexLiteral literal = REX_BUILDER.makeLiteral(null, REX_BUILDER.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN)); final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); - Assert.assertNull(fromLiteral); + Assertions.assertNull(fromLiteral); } @Test @@ -157,8 +144,8 @@ public void testGetValueFromTimestampLiteral() RexLiteral literal = REX_BUILDER.makeTimestampLiteral(new TimestampString("2021-04-01 16:54:31"), 0); final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); - Assert.assertSame(Long.class, fromLiteral.getClass()); - Assert.assertEquals(new DateTime("2021-04-01T16:54:31", TIME_ZONE).getMillis(), fromLiteral); + Assertions.assertSame(Long.class, fromLiteral.getClass()); + Assertions.assertEquals(new DateTime("2021-04-01T16:54:31", TIME_ZONE).getMillis(), fromLiteral); } @Test @@ -167,8 +154,8 @@ public void testGetValueFromDateLiteral() RexLiteral literal = REX_BUILDER.makeDateLiteral(new DateString("2021-04-01")); final Object fromLiteral = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); - Assert.assertSame(Long.class, fromLiteral.getClass()); - Assert.assertEquals(new DateTime("2021-04-01", TIME_ZONE).getMillis(), fromLiteral); + Assertions.assertSame(Long.class, fromLiteral.getClass()); + Assertions.assertEquals(new DateTime("2021-04-01", TIME_ZONE).getMillis(), fromLiteral); } @Test @@ -178,42 +165,36 @@ public void testGetValueFromTimestampWithLocalTimeZoneLiteral() new TimestampString("2021-04-01 16:54:31"), 0 ); - expectedException.expect( - DruidExceptionMatcher - .invalidSqlInput() - .expectMessageIs( - "Cannot handle literal [2021-04-01 16:54:31:TIMESTAMP_WITH_LOCAL_TIME_ZONE(0)] " - + "of unsupported type [TIMESTAMP_WITH_LOCAL_TIME_ZONE]." - ) - ); - DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); + DruidExceptionMatcher + .invalidSqlInput() + .expectMessageIs( + "Cannot handle literal [2021-04-01 16:54:31:TIMESTAMP_WITH_LOCAL_TIME_ZONE(0)] " + + "of unsupported type [TIMESTAMP_WITH_LOCAL_TIME_ZONE]." + ) + .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT)); } @Test public void testGetValueFromTimeLiteral() { RexLiteral literal = REX_BUILDER.makeTimeLiteral(new TimeString("16:54:31"), 0); - expectedException.expect( - DruidExceptionMatcher - .invalidSqlInput() - .expectMessageIs("Cannot handle literal [16:54:31] of unsupported type [TIME].") - ); - DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); + DruidExceptionMatcher + .invalidSqlInput() + .expectMessageIs("Cannot handle literal [16:54:31] of unsupported type [TIME].") + .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT)); } @Test public void testGetValueFromTimeWithLocalTimeZoneLiteral() { RexLiteral literal = REX_BUILDER.makeTimeWithLocalTimeZoneLiteral(new TimeString("16:54:31"), 0); - expectedException.expect( - DruidExceptionMatcher - .invalidSqlInput() - .expectMessageIs( - "Cannot handle literal [16:54:31:TIME_WITH_LOCAL_TIME_ZONE(0)] " - + "of unsupported type [TIME_WITH_LOCAL_TIME_ZONE]." - ) - ); - DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); + DruidExceptionMatcher + .invalidSqlInput() + .expectMessageIs( + "Cannot handle literal [16:54:31:TIME_WITH_LOCAL_TIME_ZONE(0)] " + + "of unsupported type [TIME_WITH_LOCAL_TIME_ZONE]." + ) + .assertThrowsAndMatches(() -> DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT)); } @Test @@ -224,7 +205,7 @@ public void testGetCastedValuesFromFloatToNumeric() TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER) ); Object value = DruidLogicalValuesRule.getValueFromLiteral(literal, DEFAULT_CONTEXT); - Assert.assertEquals(value, 123L); + Assertions.assertEquals(value, 123L); } } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java index 9d6bad13bd53..4cb21c160111 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/DruidUnionDataSourceRuleTest.java @@ -36,8 +36,8 @@ import org.apache.druid.sql.calcite.table.DatasourceTable.PhysicalDatasourceMetadata; import org.apache.druid.sql.calcite.table.DruidTable; import org.easymock.EasyMock; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.List; @@ -69,7 +69,7 @@ public void test_getColumnNamesIfTableOrUnion_tableScan() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.of(ImmutableList.of("__time", "col1", "col2")), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -86,7 +86,7 @@ public void test_getColumnNamesIfTableOrUnion_tableMapping() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.of(ImmutableList.of("col1")), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -103,7 +103,7 @@ public void test_getColumnNamesIfTableOrUnion_tableProject() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.empty(), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -120,7 +120,7 @@ public void test_getColumnNamesIfTableOrUnion_tableFilterPlusMapping() DruidRelsTest.mockFilter() ); - Assert.assertEquals( + Assertions.assertEquals( Optional.empty(), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -138,7 +138,7 @@ public void test_getColumnNamesIfTableOrUnion_unionScan() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.of(ImmutableList.of("__time", "col1", "col2")), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -165,7 +165,7 @@ public void test_getColumnNamesIfTableOrUnion_unionMapping() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.of(ImmutableList.of("col2", "col1")), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -183,7 +183,7 @@ public void test_getColumnNamesIfTableOrUnion_unionProject() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.of(ImmutableList.of("__time", "col1", "col2")), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -200,7 +200,7 @@ public void test_getColumnNamesIfTableOrUnion_outerQuery() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.empty(), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); @@ -217,7 +217,7 @@ public void test_getColumnNamesIfTableOrUnion_join() null ); - Assert.assertEquals( + Assertions.assertEquals( Optional.empty(), DruidUnionDataSourceRule.getColumnNamesIfTableOrUnion(druidRel, null) ); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java index bbce9836607d..acd83de6ede0 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterDecomposeConcatRuleTest.java @@ -30,8 +30,8 @@ import org.apache.druid.sql.calcite.expression.builtin.ConcatOperatorConversion; import org.apache.druid.sql.calcite.planner.DruidTypeSystem; import org.apache.druid.testing.InitializedNullHandlingTest; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.math.BigDecimal; import java.util.Arrays; @@ -51,7 +51,7 @@ public void test_notConcat() literal("2") ); - Assert.assertEquals(call, shuttle.apply(call)); + Assertions.assertEquals(call, shuttle.apply(call)); } @Test @@ -60,7 +60,7 @@ public void test_oneInput() final RexNode concatCall = concat(literal("it's "), inputRef(0)); - Assert.assertEquals( + Assertions.assertEquals( and(equals(inputRef(0), literal("2"))), shuttle.apply(equals(concatCall, literal("it's 2"))) ); @@ -72,7 +72,7 @@ public void test_oneInput_lhsLiteral() final RexNode concatCall = concat(literal("it's "), inputRef(0)); - Assert.assertEquals( + Assertions.assertEquals( and(equals(inputRef(0), literal("2"))), shuttle.apply(equals(literal("it's 2"), concatCall)) ); @@ -83,7 +83,7 @@ public void test_oneInput_noLiteral() { final RexNode concatCall = concat(inputRef(0)); - Assert.assertEquals( + Assertions.assertEquals( and(equals(inputRef(0), literal("it's 2"))), shuttle.apply(equals(literal("it's 2"), concatCall)) ); @@ -95,7 +95,7 @@ public void test_twoInputs() final RexNode concatCall = concat(inputRef(0), literal("x"), inputRef(1)); - Assert.assertEquals( + Assertions.assertEquals( and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3"))), shuttle.apply(equals(concatCall, literal("2x3"))) ); @@ -116,7 +116,7 @@ public void test_twoInputs_castNumberInputRef() final RexNode concatCall = concat(numericInputRef, literal("x"), inputRef(1)); - Assert.assertEquals( + Assertions.assertEquals( and( equals( numericInputRef, @@ -140,7 +140,7 @@ public void test_twoInputs_notEquals() literal("2x3") ); - Assert.assertEquals( + Assertions.assertEquals( rexBuilder.makeCall( SqlStdOperatorTable.NOT, and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3"))) @@ -160,7 +160,7 @@ public void test_twoInputs_castNumberLiteral() final RexNode concatCall = concat(inputRef(0), three, inputRef(1), literal("4")); - Assert.assertEquals( + Assertions.assertEquals( and(equals(inputRef(0), literal("x")), equals(inputRef(1), literal("y"))), shuttle.apply(equals(concatCall, literal("x3y4"))) ); @@ -170,7 +170,7 @@ public void test_twoInputs_castNumberLiteral() public void test_twoInputs_noLiteral() { final RexNode call = equals(concat(inputRef(0), inputRef(1)), literal("2x3")); - Assert.assertEquals(call, shuttle.apply(call)); + Assertions.assertEquals(call, shuttle.apply(call)); } @Test @@ -179,7 +179,7 @@ public void test_twoInputs_isNull() final RexNode call = isNull(concat(inputRef(0), literal("x"), inputRef(1))); - Assert.assertEquals( + Assertions.assertEquals( or(isNull(inputRef(0)), isNull(inputRef(1))), shuttle.apply(call) ); @@ -191,7 +191,7 @@ public void test_twoInputs_isNotNull() final RexNode call = notNull(concat(inputRef(0), literal("x"), inputRef(1))); - Assert.assertEquals( + Assertions.assertEquals( rexBuilder.makeCall( SqlStdOperatorTable.NOT, or(isNull(inputRef(0)), isNull(inputRef(1))) @@ -209,7 +209,7 @@ public void test_twoInputs_tooManyXes() literal("2xx3") // ambiguous match ); - Assert.assertEquals(call, shuttle.apply(call)); + Assertions.assertEquals(call, shuttle.apply(call)); } @Test @@ -222,7 +222,7 @@ public void test_twoInputs_notEnoughXes() ); final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN)); - Assert.assertEquals( + Assertions.assertEquals( or( and(isNull(inputRef(0)), unknown), and(isNull(inputRef(1)), unknown) @@ -241,7 +241,7 @@ public void test_twoInputs_delimitersWrongOrder() ); final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN)); - Assert.assertEquals( + Assertions.assertEquals( or( and(isNull(inputRef(0)), unknown), and(isNull(inputRef(1)), unknown) @@ -259,7 +259,7 @@ public void test_twoInputs_emptyDelimiter() literal("23") // must be recognized as ambiguous ); - Assert.assertEquals(call, shuttle.apply(call)); + Assertions.assertEquals(call, shuttle.apply(call)); } @Test @@ -271,7 +271,7 @@ public void test_twoInputs_ambiguousOverlappingDeliminters() literal("2---3") // must be recognized as ambiguous ); - Assert.assertEquals(call, shuttle.apply(call)); + Assertions.assertEquals(call, shuttle.apply(call)); } @Test @@ -284,7 +284,7 @@ public void test_twoInputs_impossibleOverlappingDelimiters() ); final RexLiteral unknown = rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN)); - Assert.assertEquals( + Assertions.assertEquals( or( and(isNull(inputRef(0)), unknown), and(isNull(inputRef(1)), unknown) @@ -302,7 +302,7 @@ public void test_threeInputs_delimitersIgnoredWhenOutOfPosition() literal("xxx (4x5)") // unambiguous, because 'x' before ' (' can be ignored ); - Assert.assertEquals( + Assertions.assertEquals( and( equals(inputRef(0), literal("xxx")), equals(inputRef(1), literal("4")), @@ -318,7 +318,7 @@ public void test_twoInputs_backToBackLiterals() final RexNode concatCall = concat(inputRef(0), literal("x"), literal("y"), inputRef(1)); - Assert.assertEquals( + Assertions.assertEquals( and(equals(inputRef(0), literal("2")), equals(inputRef(1), literal("3"))), shuttle.apply(equals(concatCall, literal("2xy3"))) ); diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java index 48843fc27608..9f9c503aa5b5 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/rule/FilterJoinExcludePushToChildRuleTest.java @@ -29,8 +29,8 @@ import org.apache.calcite.sql.type.SqlTypeFactoryImpl; import org.apache.calcite.sql.type.SqlTypeName; import org.apache.druid.sql.calcite.planner.DruidTypeSystem; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.List; @@ -57,16 +57,16 @@ public void testRemoveRedundantIsNotNullFiltersWithSQLCompatibility() joinFilters.add(equalityFilter); FilterJoinExcludePushToChildRule.removeRedundantIsNotNullFilters(joinFilters, JoinRelType.INNER); - Assert.assertEquals(joinFilters.size(), 1); - Assert.assertEquals("Equality Filter changed", joinFilters.get(0), equalityFilter); + Assertions.assertEquals(joinFilters.size(), 1); + Assertions.assertEquals(joinFilters.get(0), equalityFilter, "Equality Filter changed"); // add IS NOT NULL filter on a join column joinFilters.add(isNotNullFilterOnNonJoinColumn); joinFilters.add(isNotNullFilterOnJoinColumn); - Assert.assertEquals(joinFilters.size(), 3); + Assertions.assertEquals(joinFilters.size(), 3); FilterJoinExcludePushToChildRule.removeRedundantIsNotNullFilters(joinFilters, JoinRelType.INNER); - Assert.assertEquals(joinFilters.size(), 2); - Assert.assertEquals("Equality Filter changed", joinFilters.get(0), equalityFilter); - Assert.assertEquals("IS NOT NULL filter on non-join column changed", joinFilters.get(1), isNotNullFilterOnNonJoinColumn); + Assertions.assertEquals(joinFilters.size(), 2); + Assertions.assertEquals(joinFilters.get(0), equalityFilter, "Equality Filter changed"); + Assertions.assertEquals(joinFilters.get(1), isNotNullFilterOnNonJoinColumn, "IS NOT NULL filter on non-join column changed"); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java index 62190fb0c693..6547d7c881e7 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/run/DruidHookTest.java @@ -21,7 +21,7 @@ import nl.jqno.equalsverifier.EqualsVerifier; import org.apache.druid.sql.hook.DruidHook; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class DruidHookTest { diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java index 027e9022124e..64d3b1ca4c48 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/run/SqlResultsTest.java @@ -28,13 +28,10 @@ import org.apache.druid.java.util.common.StringUtils; import org.apache.druid.segment.TestHelper; import org.apache.druid.testing.InitializedNullHandlingTest; -import org.hamcrest.CoreMatchers; -import org.hamcrest.MatcherAssert; import org.joda.time.DateTimeZone; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.internal.matchers.ThrowableMessageMatcher; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.Collections; @@ -46,7 +43,7 @@ public class SqlResultsTest extends InitializedNullHandlingTest private ObjectMapper jsonMapper; - @Before + @BeforeEach public void setUp() { jsonMapper = TestHelper.JSON_MAPPER; @@ -227,10 +224,10 @@ public void testCoerceOfArrayOfPrimitives() { try { assertCoerce("", new byte[1], SqlTypeName.BIGINT); - Assert.fail("Should throw an exception"); + Assertions.fail("Should throw an exception"); } catch (Exception e) { - Assert.assertEquals("Cannot coerce field [fieldName] from type [Byte Array] to type [BIGINT]", e.getMessage()); + Assertions.assertEquals("Cannot coerce field [fieldName] from type [Byte Array] to type [BIGINT]", e.getMessage()); } } @@ -243,7 +240,7 @@ public void testCoerceUnsupportedType() @Test public void testMayNotCoerceList() { - Assert.assertEquals("hello", SqlResults.coerceArrayToList("hello", false)); + Assertions.assertEquals("hello", SqlResults.coerceArrayToList("hello", false)); } @Test @@ -254,27 +251,27 @@ public void testContextEqualsAndHashcode() private void assertCoerce(Object expected, Object toCoerce, SqlTypeName typeName) { - Assert.assertEquals( - StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName), + Assertions.assertEquals( expected, - SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "fieldName") + SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "fieldName"), + StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName) ); } private void assertCannotCoerce(Object toCoerce, SqlTypeName typeName) { - final DruidException e = Assert.assertThrows( - StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName), + final DruidException e = Assertions.assertThrows( DruidException.class, - () -> SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, "") + () -> SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, typeName, ""), + StringUtils.format("Coerce [%s] to [%s]", toCoerce, typeName) ); - MatcherAssert.assertThat(e, ThrowableMessageMatcher.hasMessage(CoreMatchers.containsString("Cannot coerce"))); + Assertions.assertTrue(e.getMessage().contains("Cannot coerce")); } private void assertCoerceArrayToList(Object expected, Object toCoerce) { Object coerced = SqlResults.coerce(jsonMapper, DEFAULT_CONTEXT, toCoerce, SqlTypeName.ARRAY, ""); - Assert.assertEquals(expected, coerced); + Assertions.assertEquals(expected, coerced); } } diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java index 487c50570f3b..f5dc46550f94 100644 --- a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java +++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestFramework.java @@ -126,6 +126,7 @@ import org.apache.druid.utils.JvmUtils; import javax.inject.Named; + import java.io.Closeable; import java.io.File; import java.io.IOException; @@ -986,21 +987,21 @@ GroupByResourcesReservationPool makeMergingGroupByResourcesReservationPool( @LazySingleton public DruidProcessingConfig makeProcessingConfig(Builder builder) { - return QueryStackTests.getProcessingConfig(builder.mergeBufferCount); + return SqlTestQueryStack.getProcessingConfig(builder.mergeBufferCount); } @Provides @LazySingleton public TestBufferPool makeTestBufferPool(Builder builder) { - return QueryStackTests.makeTestBufferPool(builder.resourceCloser); + return SqlTestQueryStack.makeTestBufferPool(builder.resourceCloser); } @Provides @LazySingleton public TestGroupByBuffers makeTestGroupByBuffers(DruidProcessingConfig processingConfig, Builder builder) { - return QueryStackTests.makeGroupByBuffers(builder.resourceCloser, processingConfig); + return SqlTestQueryStack.makeGroupByBuffers(builder.resourceCloser, processingConfig); } @Provides diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestQueryStack.java b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestQueryStack.java new file mode 100644 index 000000000000..8a137874fc8c --- /dev/null +++ b/sql/src/test/java/org/apache/druid/sql/calcite/util/SqlTestQueryStack.java @@ -0,0 +1,235 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.druid.sql.calcite.util; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; +import org.apache.druid.java.util.common.ISE; +import org.apache.druid.java.util.common.io.Closer; +import org.apache.druid.query.DefaultGenericQueryMetricsFactory; +import org.apache.druid.query.DefaultQueryRunnerFactoryConglomerate; +import org.apache.druid.query.DruidProcessingConfig; +import org.apache.druid.query.Query; +import org.apache.druid.query.QueryRunnerFactory; +import org.apache.druid.query.QueryRunnerFactoryConglomerate; +import org.apache.druid.query.QueryRunnerTestHelper; +import org.apache.druid.query.TestBufferPool; +import org.apache.druid.query.groupby.DefaultGroupByQueryMetricsFactory; +import org.apache.druid.query.groupby.GroupByQuery; +import org.apache.druid.query.groupby.GroupByQueryConfig; +import org.apache.druid.query.groupby.GroupByQueryQueryToolChest; +import org.apache.druid.query.groupby.GroupByQueryRunnerFactory; +import org.apache.druid.query.groupby.GroupByResourcesReservationPool; +import org.apache.druid.query.groupby.GroupByStatsProvider; +import org.apache.druid.query.groupby.GroupingEngine; +import org.apache.druid.query.groupby.TestGroupByBuffers; +import org.apache.druid.query.metadata.SegmentMetadataQueryConfig; +import org.apache.druid.query.metadata.SegmentMetadataQueryQueryToolChest; +import org.apache.druid.query.metadata.SegmentMetadataQueryRunnerFactory; +import org.apache.druid.query.metadata.metadata.SegmentMetadataQuery; +import org.apache.druid.query.operator.WindowOperatorQuery; +import org.apache.druid.query.operator.WindowOperatorQueryQueryRunnerFactory; +import org.apache.druid.query.operator.WindowOperatorQueryQueryToolChest; +import org.apache.druid.query.scan.ScanQuery; +import org.apache.druid.query.scan.ScanQueryConfig; +import org.apache.druid.query.scan.ScanQueryEngine; +import org.apache.druid.query.scan.ScanQueryQueryToolChest; +import org.apache.druid.query.scan.ScanQueryRunnerFactory; +import org.apache.druid.query.search.SearchQuery; +import org.apache.druid.query.search.SearchQueryConfig; +import org.apache.druid.query.search.SearchQueryQueryToolChest; +import org.apache.druid.query.search.SearchQueryRunnerFactory; +import org.apache.druid.query.search.SearchStrategySelector; +import org.apache.druid.query.timeboundary.TimeBoundaryQuery; +import org.apache.druid.query.timeboundary.TimeBoundaryQueryRunnerFactory; +import org.apache.druid.query.timeseries.TimeseriesQuery; +import org.apache.druid.query.timeseries.TimeseriesQueryEngine; +import org.apache.druid.query.timeseries.TimeseriesQueryQueryToolChest; +import org.apache.druid.query.timeseries.TimeseriesQueryRunnerFactory; +import org.apache.druid.query.topn.TopNQuery; +import org.apache.druid.query.topn.TopNQueryConfig; +import org.apache.druid.query.topn.TopNQueryQueryToolChest; +import org.apache.druid.query.topn.TopNQueryRunnerFactory; +import org.apache.druid.query.union.UnionQuery; +import org.apache.druid.query.union.UnionQueryLogic; +import org.apache.druid.segment.TestHelper; +import org.junit.jupiter.api.Assertions; + +public class SqlTestQueryStack +{ + private static final int COMPUTE_BUFFER_SIZE = 10 * 1024 * 1024; + + private SqlTestQueryStack() + { + } + + public static DruidProcessingConfig getProcessingConfig(final int mergeBuffers) + { + return new DruidProcessingConfig() + { + @Override + public String getFormatString() + { + return null; + } + + @Override + public int intermediateComputeSizeBytes() + { + return COMPUTE_BUFFER_SIZE; + } + + @Override + public int getNumThreads() + { + return 1; + } + + @Override + public int getNumMergeBuffers() + { + return mergeBuffers < 0 ? 2 : mergeBuffers; + } + }; + } + + public static TestBufferPool makeTestBufferPool(final Closer closer) + { + final TestBufferPool testBufferPool = TestBufferPool.offHeap(COMPUTE_BUFFER_SIZE, Integer.MAX_VALUE); + closer.register(() -> Assertions.assertEquals(0, testBufferPool.getOutstandingObjectCount())); + return testBufferPool; + } + + public static TestGroupByBuffers makeGroupByBuffers( + final Closer closer, + final DruidProcessingConfig processingConfig + ) + { + return closer.register(TestGroupByBuffers.createFromProcessingConfig(processingConfig)); + } + + public static QueryRunnerFactoryConglomerate createQueryRunnerFactoryConglomerate(final Closer closer) + { + final DruidProcessingConfig processingConfig = getProcessingConfig(-1); + final TestBufferPool testBufferPool = makeTestBufferPool(closer); + final TestGroupByBuffers groupByBuffers = makeGroupByBuffers(closer, processingConfig); + final ObjectMapper jsonMapper = TestHelper.makeJsonMapper(); + + final ImmutableMap, QueryRunnerFactory> factories = ImmutableMap + ., QueryRunnerFactory>builder() + .put( + SegmentMetadataQuery.class, + new SegmentMetadataQueryRunnerFactory( + new SegmentMetadataQueryQueryToolChest(new SegmentMetadataQueryConfig("P1W")), + QueryRunnerTestHelper.NOOP_QUERYWATCHER + ) + ) + .put( + SearchQuery.class, + new SearchQueryRunnerFactory( + new SearchStrategySelector(Suppliers.ofInstance(new SearchQueryConfig())), + new SearchQueryQueryToolChest(new SearchQueryConfig()), + QueryRunnerTestHelper.NOOP_QUERYWATCHER + ) + ) + .put( + ScanQuery.class, + new ScanQueryRunnerFactory( + new ScanQueryQueryToolChest(DefaultGenericQueryMetricsFactory.instance()), + new ScanQueryEngine(), + new ScanQueryConfig() + ) + ) + .put( + TimeseriesQuery.class, + new TimeseriesQueryRunnerFactory( + new TimeseriesQueryQueryToolChest(), + new TimeseriesQueryEngine(), + QueryRunnerTestHelper.NOOP_QUERYWATCHER + ) + ) + .put( + TopNQuery.class, + new TopNQueryRunnerFactory( + testBufferPool, + new TopNQueryQueryToolChest(new TopNQueryConfig()), + QueryRunnerTestHelper.NOOP_QUERYWATCHER + ) + ) + .put(GroupByQuery.class, makeGroupByQueryRunnerFactory(jsonMapper, groupByBuffers, processingConfig)) + .put(TimeBoundaryQuery.class, new TimeBoundaryQueryRunnerFactory(QueryRunnerTestHelper.NOOP_QUERYWATCHER)) + .put( + WindowOperatorQuery.class, + new WindowOperatorQueryQueryRunnerFactory( + new WindowOperatorQueryQueryToolChest(DefaultGenericQueryMetricsFactory.instance()) + ) + ) + .build(); + final UnionQueryLogic unionQueryLogic = new UnionQueryLogic(); + final QueryRunnerFactoryConglomerate conglomerate = new DefaultQueryRunnerFactoryConglomerate( + factories, + Maps.transformValues(factories, QueryRunnerFactory::getToolchest), + ImmutableMap.of(UnionQuery.class, unionQueryLogic) + ); + unionQueryLogic.initialize(conglomerate); + return conglomerate; + } + + private static GroupByQueryRunnerFactory makeGroupByQueryRunnerFactory( + final ObjectMapper mapper, + final TestGroupByBuffers bufferPools, + final DruidProcessingConfig processingConfig + ) + { + if (bufferPools.getBufferSize() != processingConfig.intermediateComputeSizeBytes()) { + throw new ISE("Provided buffer size [%,d] does not match configured size [%,d]", + bufferPools.getBufferSize(), processingConfig.intermediateComputeSizeBytes()); + } + if (bufferPools.getNumMergeBuffers() != processingConfig.getNumMergeBuffers()) { + throw new ISE("Provided merge buffer count [%,d] does not match configured count [%,d]", + bufferPools.getNumMergeBuffers(), processingConfig.getNumMergeBuffers()); + } + final GroupByQueryConfig config = new GroupByQueryConfig(); + final Supplier configSupplier = Suppliers.ofInstance(config); + final GroupByStatsProvider statsProvider = new GroupByStatsProvider(); + final GroupByResourcesReservationPool reservationPool = + new GroupByResourcesReservationPool(bufferPools.getMergePool(), config); + final GroupingEngine groupingEngine = new GroupingEngine( + processingConfig, + configSupplier, + reservationPool, + mapper, + mapper, + QueryRunnerTestHelper.NOOP_QUERYWATCHER, + statsProvider + ); + final GroupByQueryQueryToolChest toolChest = new GroupByQueryQueryToolChest( + groupingEngine, + configSupplier, + DefaultGroupByQueryMetricsFactory.instance(), + reservationPool, + statsProvider + ); + return new GroupByQueryRunnerFactory(groupingEngine, toolChest, bufferPools.getProcessingPool()); + } +} diff --git a/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java b/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java index a06de536a2fa..1903337108bc 100644 --- a/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java +++ b/sql/src/test/java/org/apache/druid/sql/destination/ExportDestinationTest.java @@ -27,8 +27,8 @@ import org.apache.druid.storage.StorageConfig; import org.apache.druid.storage.StorageConnectorModule; import org.apache.druid.storage.local.LocalFileExportStorageProvider; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.io.IOException; @@ -61,6 +61,6 @@ public Object findInjectableValue( byte[] bytes = objectMapper.writeValueAsBytes(exportDestination); ExportDestination deserialized = objectMapper.readValue(bytes, ExportDestination.class); - Assert.assertEquals(exportDestination, deserialized); + Assertions.assertEquals(exportDestination, deserialized); } } diff --git a/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java b/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java index 7af4ad2eb4d6..0f76cfb9f1e3 100644 --- a/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java +++ b/sql/src/test/java/org/apache/druid/sql/destination/TableDestinationTest.java @@ -21,8 +21,8 @@ import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.druid.jackson.DefaultObjectMapper; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import java.io.IOException; @@ -37,6 +37,6 @@ public void testSerde() throws IOException byte[] bytes = objectMapper.writeValueAsBytes(tableDestination); TableDestination deserialized = objectMapper.readValue(bytes, TableDestination.class); - Assert.assertEquals(tableDestination, deserialized); + Assertions.assertEquals(tableDestination, deserialized); } } diff --git a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java index e04032a66379..b1154ebb9776 100644 --- a/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/guice/SqlModuleTest.java @@ -74,19 +74,20 @@ import org.apache.druid.sql.calcite.view.ViewManager; import org.apache.druid.sql.http.SqlResourceTest; import org.easymock.EasyMock; -import org.easymock.EasyMockRunner; +import org.easymock.EasyMockExtension; import org.easymock.Mock; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import javax.validation.Validation; import javax.validation.Validator; + import java.util.Map; import java.util.Properties; -@RunWith(EasyMockRunner.class) +@ExtendWith(EasyMockExtension.class) public class SqlModuleTest { @Mock @@ -130,7 +131,7 @@ public class SqlModuleTest private Injector injector; - @Before + @BeforeEach public void setUp() { EasyMock.replay( @@ -160,8 +161,8 @@ public void testDefaultViewManagerBind() injector = makeInjectorWithProperties(props); ViewManager viewManager = injector.getInstance(Key.get(ViewManager.class)); - Assert.assertNotNull(viewManager); - Assert.assertTrue(viewManager instanceof NoopViewManager); + Assertions.assertNotNull(viewManager); + Assertions.assertTrue(viewManager instanceof NoopViewManager); } @Test @@ -176,8 +177,8 @@ public void testNonDefaultViewManagerBind() injector = makeInjectorWithProperties(props); ViewManager viewManager = injector.getInstance(Key.get(ViewManager.class)); - Assert.assertNotNull(viewManager); - Assert.assertTrue(viewManager instanceof BindTestViewManager); + Assertions.assertNotNull(viewManager); + Assertions.assertTrue(viewManager instanceof BindTestViewManager); } private Injector makeInjectorWithProperties(final Properties props) diff --git a/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java b/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java index 37ee6de032ab..a270b1763731 100644 --- a/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java +++ b/sql/src/test/java/org/apache/druid/sql/http/ResultFormatTest.java @@ -23,7 +23,7 @@ import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.java.util.common.StringUtils; -import org.junit.Assert; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -39,17 +39,17 @@ public class ResultFormatTest public void testSerde(ResultFormat target) throws JsonProcessingException { final String json = jsonMapper.writeValueAsString(target); - Assert.assertEquals(StringUtils.format("\"%s\"", target.toString()), json); - Assert.assertEquals(target, jsonMapper.readValue(json, ResultFormat.class)); + Assertions.assertEquals(StringUtils.format("\"%s\"", target.toString()), json); + Assertions.assertEquals(target, jsonMapper.readValue(json, ResultFormat.class)); } @Test public void testDeserializeWithDifferentCase() throws JsonProcessingException { - Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"OBJECTLINES\"", ResultFormat.class)); - Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectLines\"", ResultFormat.class)); - Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectlines\"", ResultFormat.class)); - Assert.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"oBjEcTlInEs\"", ResultFormat.class)); + Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"OBJECTLINES\"", ResultFormat.class)); + Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectLines\"", ResultFormat.class)); + Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"objectlines\"", ResultFormat.class)); + Assertions.assertEquals(ResultFormat.OBJECTLINES, jsonMapper.readValue("\"oBjEcTlInEs\"", ResultFormat.class)); } public static Object[] provideResultFormats() diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java index 87a501f00a84..67d6033a2416 100644 --- a/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java +++ b/sql/src/test/java/org/apache/druid/sql/http/SqlHttpModuleTest.java @@ -39,17 +39,17 @@ import org.apache.druid.sql.SqlStatementFactory; import org.apache.druid.sql.calcite.run.NativeSqlEngine; import org.easymock.EasyMock; -import org.easymock.EasyMockRunner; +import org.easymock.EasyMockExtension; import org.easymock.Mock; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import java.util.Collections; import java.util.Set; -@RunWith(EasyMockRunner.class) +@ExtendWith(EasyMockExtension.class) public class SqlHttpModuleTest { @Mock @@ -58,7 +58,7 @@ public class SqlHttpModuleTest private SqlHttpModule target; private Injector injector; - @Before + @BeforeEach public void setUp() { target = new SqlHttpModule(); @@ -85,9 +85,9 @@ public void setUp() public void testSqlResourceIsInjectedAndSingleton() { SqlResource sqlResource = injector.getInstance(SqlResource.class); - Assert.assertNotNull(sqlResource); + Assertions.assertNotNull(sqlResource); SqlResource other = injector.getInstance(SqlResource.class); - Assert.assertSame(other, sqlResource); + Assertions.assertSame(other, sqlResource); } @Test @@ -95,7 +95,7 @@ public void testSqlResourceIsAvailableViaJersey() { Set> jerseyResourceClasses = injector.getInstance(Key.get(new TypeLiteral<>() {}, JSR311Resource.class)); - Assert.assertEquals(1, jerseyResourceClasses.size()); - Assert.assertEquals(SqlResource.class, jerseyResourceClasses.iterator().next()); + Assertions.assertEquals(1, jerseyResourceClasses.size()); + Assertions.assertEquals(SqlResource.class, jerseyResourceClasses.iterator().next()); } } diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java index 90aac37aa455..52d16d9787e4 100644 --- a/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java +++ b/sql/src/test/java/org/apache/druid/sql/http/SqlQueryTest.java @@ -23,11 +23,12 @@ import org.apache.druid.jackson.DefaultObjectMapper; import org.apache.druid.server.initialization.jetty.HttpException; import org.easymock.EasyMock; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import javax.servlet.http.HttpServletRequest; import javax.ws.rs.core.Response; + import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; @@ -45,7 +46,7 @@ public void testFromHttpServletRequestWithJsonContentType() throws Exception SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT 1", result.getQuery()); + Assertions.assertEquals("SELECT 1", result.getQuery()); } @Test @@ -56,7 +57,7 @@ public void testFromHttpServletRequestWithJsonContentTypeAndCharset() throws Exc SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT 2", result.getQuery()); + Assertions.assertEquals("SELECT 2", result.getQuery()); } @Test @@ -67,7 +68,7 @@ public void testFromHttpServletRequestWithJsonContentTypeAndMultipleParams() thr SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT 3", result.getQuery()); + Assertions.assertEquals("SELECT 3", result.getQuery()); } @Test @@ -78,7 +79,7 @@ public void testFromHttpServletRequestWithTextPlainContentType() throws Exceptio SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT 4", result.getQuery()); + Assertions.assertEquals("SELECT 4", result.getQuery()); } @Test @@ -89,7 +90,7 @@ public void testFromHttpServletRequestWithTextPlainContentTypeAndCharset() throw SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT 5", result.getQuery()); + Assertions.assertEquals("SELECT 5", result.getQuery()); } @Test @@ -100,7 +101,7 @@ public void testFromHttpServletRequestWithFormUrlencodedContentType() throws Exc SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT 6", result.getQuery()); + Assertions.assertEquals("SELECT 6", result.getQuery()); } @Test @@ -111,7 +112,7 @@ public void testFromHttpServletRequestWithFormUrlencodedContentTypeAndCharset() SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT 7", result.getQuery()); + Assertions.assertEquals("SELECT 7", result.getQuery()); } @Test @@ -120,13 +121,13 @@ public void testFromHttpServletRequestWithNullContentType() throws Exception String content = "SELECT 8"; HttpServletRequest request = createMockRequest(null, content); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); - Assert.assertEquals("Missing Content-Type header", exception.getMessage()); + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertEquals("Missing Content-Type header", exception.getMessage()); } @Test @@ -135,14 +136,14 @@ public void testFromHttpServletRequestWithUnsupportedContentType() throws Except String xmlQuery = "SELECT 9"; HttpServletRequest request = createMockRequest("application/xml", xmlQuery); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode()); - Assert.assertTrue(exception.getMessage().contains("Unsupported Content-Type")); - Assert.assertTrue(exception.getMessage().contains("application/xml")); + Assertions.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode()); + Assertions.assertTrue(exception.getMessage().contains("Unsupported Content-Type")); + Assertions.assertTrue(exception.getMessage().contains("application/xml")); } @Test @@ -151,14 +152,14 @@ public void testFromHttpServletRequestWithUnsupportedContentTypeWithParams() thr String xmlQuery = "SELECT 10"; HttpServletRequest request = createMockRequest("application/xml; charset=UTF-8", xmlQuery); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode()); - Assert.assertTrue(exception.getMessage().contains("Unsupported Content-Type")); - Assert.assertTrue(exception.getMessage().contains("application/xml")); + Assertions.assertEquals(Response.Status.UNSUPPORTED_MEDIA_TYPE, exception.getStatusCode()); + Assertions.assertTrue(exception.getMessage().contains("Unsupported Content-Type")); + Assertions.assertTrue(exception.getMessage().contains("application/xml")); } @Test @@ -167,13 +168,13 @@ public void testFromHttpServletRequestWithInvalidContentTypeFormat() throws Exce String content = "SELECT 11"; HttpServletRequest request = createMockRequest("invalid-content-type-format", content); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); - Assert.assertTrue(exception.getMessage().contains("Invalid Content-Type header")); + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertTrue(exception.getMessage().contains("Invalid Content-Type header")); } @Test @@ -182,13 +183,13 @@ public void testFromHttpServletRequestWithEmptyJsonQuery() throws Exception String jsonQuery = "{}"; HttpServletRequest request = createMockRequest("application/json", jsonQuery); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); - Assert.assertTrue(exception.getMessage() + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertTrue(exception.getMessage() .contains("Unable to read query from request: Cannot construct instance of ")); } @@ -198,12 +199,12 @@ public void testFromHttpServletRequestWithNullJsonQuery() throws Exception String jsonQuery = "{\"query\": null}"; HttpServletRequest request = createMockRequest("application/json", jsonQuery); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); } @Test @@ -212,13 +213,13 @@ public void testFromHttpServletRequestWithEmptyTextQuery() throws Exception String textQuery = ""; HttpServletRequest request = createMockRequest("text/plain", textQuery); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); - Assert.assertEquals("Empty query", exception.getMessage()); + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertEquals("Empty query", exception.getMessage()); } @Test @@ -227,13 +228,13 @@ public void testFromHttpServletRequestWithWhitespaceOnlyTextQuery() throws Excep String textQuery = " \n\t "; HttpServletRequest request = createMockRequest("text/plain", textQuery); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); - Assert.assertEquals("Empty query", exception.getMessage()); + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertEquals("Empty query", exception.getMessage()); } @Test @@ -242,13 +243,13 @@ public void testFromHttpServletRequestWithEmptyFormUrlencodedQuery() throws Exce String formQuery = ""; HttpServletRequest request = createMockRequest("application/x-www-form-urlencoded", formQuery); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); - Assert.assertEquals("Empty query", exception.getMessage()); + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertEquals("Empty query", exception.getMessage()); } @@ -258,13 +259,13 @@ public void testFromHttpServletRequestWithMalformedJson() throws Exception String malformedJson = "{\"query\":\"SELECT 12\""; // Missing closing brace HttpServletRequest request = createMockRequest("application/json", malformedJson); - HttpException exception = Assert.assertThrows( + HttpException exception = Assertions.assertThrows( HttpException.class, () -> SqlQuery.from(request, objectMapper) ); - Assert.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); - Assert.assertTrue(exception.getMessage().contains("Malformed SQL query wrapped in JSON: Unexpected end-of-input:")); + Assertions.assertEquals(Response.Status.BAD_REQUEST, exception.getStatusCode()); + Assertions.assertTrue(exception.getMessage().contains("Malformed SQL query wrapped in JSON: Unexpected end-of-input:")); } @Test @@ -275,16 +276,16 @@ public void testFromHttpServletRequestWithCaseInsensitiveContentType() throws Ex HttpServletRequest request1 = createMockRequest("APPLICATION/JSON", jsonQuery); SqlQuery result1 = SqlQuery.from(request1, objectMapper); - Assert.assertEquals("SELECT 13", result1.getQuery()); + Assertions.assertEquals("SELECT 13", result1.getQuery()); HttpServletRequest request2 = createMockRequest("Application/Json; Charset=UTF-8", jsonQuery); SqlQuery result2 = SqlQuery.from(request2, objectMapper); - Assert.assertEquals("SELECT 13", result2.getQuery()); + Assertions.assertEquals("SELECT 13", result2.getQuery()); String textQuery = "SELECT 14"; HttpServletRequest request3 = createMockRequest("TEXT/PLAIN", textQuery); SqlQuery result3 = SqlQuery.from(request3, objectMapper); - Assert.assertEquals("SELECT 14", result3.getQuery()); + Assertions.assertEquals("SELECT 14", result3.getQuery()); } @Test @@ -295,9 +296,9 @@ public void testFromHttpServletRequestWithComplexJsonQuery() throws Exception SqlQuery result = SqlQuery.from(request, objectMapper); - Assert.assertEquals("SELECT COUNT(*) FROM table WHERE col > 100", result.getQuery()); - Assert.assertTrue(result.includeHeader()); - Assert.assertNotNull(result.getContext()); + Assertions.assertEquals("SELECT COUNT(*) FROM table WHERE col > 100", result.getQuery()); + Assertions.assertTrue(result.includeHeader()); + Assertions.assertNotNull(result.getContext()); } diff --git a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java index 6fb974a527cd..da5b235e238f 100644 --- a/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java +++ b/sql/src/test/java/org/apache/druid/sql/http/SqlResourceTest.java @@ -70,7 +70,6 @@ import org.apache.druid.server.QueryResource; import org.apache.druid.server.QueryResponse; import org.apache.druid.server.QueryScheduler; -import org.apache.druid.server.QueryStackTests; import org.apache.druid.server.ResponseContextConfig; import org.apache.druid.server.SpecificSegmentsQuerySegmentWalker; import org.apache.druid.server.initialization.ServerConfig; @@ -104,11 +103,11 @@ import org.apache.druid.sql.calcite.schema.DruidSchemaCatalog; import org.apache.druid.sql.calcite.util.CalciteTestBase; import org.apache.druid.sql.calcite.util.CalciteTests; +import org.apache.druid.sql.calcite.util.SqlTestQueryStack; import org.apache.druid.sql.hook.DruidHookDispatcher; -import org.hamcrest.CoreMatchers; -import org.junit.Assert; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -121,6 +120,7 @@ import javax.ws.rs.core.Response; import javax.ws.rs.core.Response.Status; import javax.ws.rs.core.StreamingOutput; + import java.io.ByteArrayOutputStream; import java.io.File; import java.io.IOException; @@ -197,7 +197,7 @@ public class SqlResourceTest extends CalciteTestBase @BeforeAll public static void setupClass(@TempDir File tempDir) { - conglomerate = QueryStackTests.createQueryRunnerFactoryConglomerate(staticCloser); + conglomerate = SqlTestQueryStack.createQueryRunnerFactoryConglomerate(staticCloser); scheduler = new QueryScheduler( 5, ManualQueryPrioritizationStrategy.INSTANCE, @@ -357,12 +357,12 @@ public void tearDown() throws Exception @Test public void testUnauthorized() { - ForbiddenException e = Assert.assertThrows(ForbiddenException.class, () -> { + ForbiddenException e = Assertions.assertThrows(ForbiddenException.class, () -> { postForAsyncResponse(createSimpleQueryWithId("id", "select count(*) from forbiddenDatasource"), request()); }); - Assert.assertEquals("Unauthorized", e.getMessage()); - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertEquals("Unauthorized", e.getMessage()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } @Test @@ -373,21 +373,21 @@ public void testRestricted() throws Exception "id", "select count(*) as cnt from restrictedDatasource_m1_is_6" )).rhs; - Assert.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 6)), resultAsSuperUser); + Assertions.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 6)), resultAsSuperUser); checkSqlRequestLog(true, CalciteTests.TEST_SUPERUSER_NAME); testRequestLogger.clear(); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); req = makeRegularUserReq(); final List> resultAsRegularUser = doPost(createSimpleQueryWithId( "id", "select count(*) as cnt from restrictedDatasource_m1_is_6" )).rhs; - Assert.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 1)), resultAsRegularUser); + Assertions.assertEquals(ImmutableList.of(ImmutableMap.of("cnt", 1)), resultAsRegularUser); checkSqlRequestLog(true); testRequestLogger.clear(); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } @Test @@ -397,16 +397,16 @@ public void testCountStar() throws Exception createSimpleQueryWithId("id", "SELECT COUNT(*) AS cnt, 'foo' AS TheFoo FROM druid.foo") ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 6, "TheFoo", "foo") ), rows ); checkSqlRequestLog(true); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -414,7 +414,7 @@ public void test_getEnabled() { Response response = resource.getSupportedEngines(req); Set supportedEngines = ((SupportedEnginesResponse) response.getEntity()).getEngines(); - Assert.assertTrue(supportedEngines.contains(new EngineInfo(NativeSqlEngine.NAME))); + Assertions.assertTrue(supportedEngines.contains(new EngineInfo(NativeSqlEngine.NAME))); } @Test @@ -462,18 +462,18 @@ public void testCountStarWithMissingIntervalsContext() throws Exception }) .collect(Collectors.toList()); - Assert.assertEquals(expectedMissingHeaders, observedMissingHeaders); + Assertions.assertEquals(expectedMissingHeaders, observedMissingHeaders); Object results = JSON_MAPPER.readValue(response.baos.toByteArray(), Object.class); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 6, "TheFoo", "foo") ), results ); checkSqlRequestLog(true); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } @Test @@ -483,18 +483,18 @@ public void testSqlLifecycleMetrics() throws Exception createSimpleQueryWithId("id", "SELECT COUNT(*) AS cnt, 'foo' AS TheFoo FROM druid.foo") ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 6, "TheFoo", "foo") ), rows ); checkSqlRequestLog(true); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); stubServiceEmitter.verifyValue("sqlQuery/bytes", 27L); stubServiceEmitter.verifyEmitted("sqlQuery/planningTimeMs", 1); - Assert.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(200, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @@ -508,14 +508,14 @@ public void testCountStarExtendedCharacters() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("cnt", 1) ), rows ); checkSqlRequestLog(true); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } @Test @@ -533,7 +533,7 @@ public void testTimestampsInResponse() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("__time", "2000-01-01T00:00:00.000Z", "t2", "2000-01-01T00:00:00.000Z") ), @@ -556,7 +556,7 @@ public void testTimestampsInResponseWithParameterizedLimit() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("__time", "2000-01-01T00:00:00.000Z", "t2", "2000-01-01T00:00:00.000Z") ), @@ -579,7 +579,7 @@ public void testTimestampsInResponseLosAngelesTimeZone() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("__time", "1999-12-31T16:00:00.000-08:00", "t2", "1999-12-31T00:00:00.000-08:00") ), @@ -622,7 +622,7 @@ public void testTimestampsInResponseLosAngelesTimeZone_setViaDefaultQueryConfig( ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("__time", "1999-12-31T16:00:00.000-08:00", "t2", "1999-12-31T00:00:00.000-08:00") ), @@ -645,7 +645,7 @@ public void testTimestampsInResponseWithNulls() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( Maps.transformValues( ImmutableMap.of("t1", "2001-01-03T00:00:00.000Z", "t2", ""), @@ -671,7 +671,7 @@ public void testFieldAliasingSelect() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("x", "a", "y", "a") ), @@ -694,7 +694,7 @@ public void testFieldAliasingGroupBy() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( // x and y both should be null instead of empty string Maps.transformValues(ImmutableMap.of("x", "", "y", ""), (val) -> null), @@ -746,7 +746,7 @@ public void testPivotRowTypePreservedInDecoupledPlanner() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("Age", "18-19", "Women", 0.040737148399612025, "Men", 0.1052376333656644), ImmutableMap.of("Age", "20-29", "Women", 0.1556741028128031, "Men", 0.3976721629485936), @@ -797,7 +797,7 @@ public void testPivotRowTypePreservedInCoupledPlanner() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of("Age", "18-19", "Women", 0.040737148399612025, "Men", 0.1052376333656644), ImmutableMap.of("Age", "20-29", "Women", 0.1556741028128031, "Men", 0.3976721629485936), @@ -814,7 +814,7 @@ public void testArrayResultFormat() throws Exception { final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2"; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( Arrays.asList( "2000-01-01T00:00:00.000Z", @@ -858,8 +858,8 @@ public void testArrayResultFormatWithErrorAfterSecondRow() throws Exception doPostRaw(new SqlQuery(query, ResultFormat.ARRAY, false, false, false, null, null), req); // Truncated response: missing final ] - Assert.assertNull(response.lhs); - Assert.assertEquals("[[1],[1]", response.rhs); + Assertions.assertNull(response.lhs); + Assertions.assertEquals("[[1],[1]", response.rhs); } @Test @@ -872,8 +872,8 @@ public void testObjectResultFormatWithErrorAfterFirstRow() throws Exception doPostRaw(new SqlQuery(query, ResultFormat.OBJECT, false, false, false, null, null), req); // Truncated response: missing final ] - Assert.assertNull(response.lhs); - Assert.assertEquals("[{\"cnt\":1},{\"cnt\":1}", response.rhs); + Assertions.assertNull(response.lhs); + Assertions.assertEquals("[{\"cnt\":1},{\"cnt\":1}", response.rhs); } @Test @@ -886,8 +886,8 @@ public void testArrayLinesResultFormatWithErrorAfterFirstRow() throws Exception doPostRaw(new SqlQuery(query, ResultFormat.ARRAYLINES, false, false, false, null, null), req); // Truncated response: missing final LFLF - Assert.assertNull(response.lhs); - Assert.assertEquals("[1]\n[1]", response.rhs); + Assertions.assertNull(response.lhs); + Assertions.assertEquals("[1]\n[1]", response.rhs); } @Test @@ -900,8 +900,8 @@ public void testObjectLinesResultFormatWithErrorAfterFirstRow() throws Exception doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, false, false, false, null, null), req); // Truncated response: missing final LFLF - Assert.assertNull(response.lhs); - Assert.assertEquals("{\"cnt\":1}\n{\"cnt\":1}", response.rhs); + Assertions.assertNull(response.lhs); + Assertions.assertEquals("{\"cnt\":1}\n{\"cnt\":1}", response.rhs); } @Test @@ -914,8 +914,8 @@ public void testCsvResultFormatWithErrorAfterFirstRow() throws Exception doPostRaw(new SqlQuery(query, ResultFormat.CSV, false, false, false, null, null), req); // Truncated response: missing final LFLF - Assert.assertNull(response.lhs); - Assert.assertEquals("1\n1\n", response.rhs); + Assertions.assertNull(response.lhs); + Assertions.assertEquals("1\n1\n", response.rhs); } @Test @@ -934,9 +934,9 @@ public void testArrayResultFormatWithHeader() throws Exception req.mimic() ); - Assert.assertEquals(200, response.getStatus()); - Assert.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included")); - Assert.assertEquals( + Assertions.assertEquals(200, response.getStatus()); + Assertions.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included")); + Assertions.assertEquals( ImmutableList.builder() .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS) .add(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS) @@ -951,9 +951,9 @@ public void testArrayResultFormatWithHeader() throws Exception req.mimic() ); - Assert.assertEquals(200, responseNoSqlTypesHeader.getStatus()); - Assert.assertEquals("yes", responseNoSqlTypesHeader.getHeader("X-Druid-SQL-Header-Included")); - Assert.assertEquals( + Assertions.assertEquals(200, responseNoSqlTypesHeader.getStatus()); + Assertions.assertEquals("yes", responseNoSqlTypesHeader.getHeader("X-Druid-SQL-Header-Included")); + Assertions.assertEquals( ImmutableList.builder() .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS) .add(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS) @@ -967,9 +967,9 @@ public void testArrayResultFormatWithHeader() throws Exception req.mimic() ); - Assert.assertEquals(200, responseNoTypesHeader.getStatus()); - Assert.assertEquals("yes", responseNoTypesHeader.getHeader("X-Druid-SQL-Header-Included")); - Assert.assertEquals( + Assertions.assertEquals(200, responseNoTypesHeader.getStatus()); + Assertions.assertEquals("yes", responseNoTypesHeader.getHeader("X-Druid-SQL-Header-Included")); + Assertions.assertEquals( ImmutableList.builder() .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS) .add(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS) @@ -983,9 +983,9 @@ public void testArrayResultFormatWithHeader() throws Exception req.mimic() ); - Assert.assertEquals(200, responseNoTypes.getStatus()); - Assert.assertEquals("yes", responseNoTypes.getHeader("X-Druid-SQL-Header-Included")); - Assert.assertEquals( + Assertions.assertEquals(200, responseNoTypes.getStatus()); + Assertions.assertEquals("yes", responseNoTypes.getHeader("X-Druid-SQL-Header-Included")); + Assertions.assertEquals( ImmutableList.builder() .add(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS) .addAll(Arrays.asList(expectedQueryResults)) @@ -998,9 +998,9 @@ public void testArrayResultFormatWithHeader() throws Exception req.mimic() ); - Assert.assertEquals(200, responseNoHeader.getStatus()); - Assert.assertNull(responseNoHeader.getHeader("X-Druid-SQL-Header-Included")); - Assert.assertEquals( + Assertions.assertEquals(200, responseNoHeader.getStatus()); + Assertions.assertNull(responseNoHeader.getHeader("X-Druid-SQL-Header-Included")); + Assertions.assertEquals( Arrays.asList(expectedQueryResults), JSON_MAPPER.readValue(responseNoHeader.baos.toByteArray(), Object.class) ); @@ -1018,10 +1018,10 @@ public void testArrayResultFormatWithHeader_nullColumnType() throws Exception req ); - Assert.assertEquals(200, response.getStatus()); - Assert.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included")); + Assertions.assertEquals(200, response.getStatus()); + Assertions.assertEquals("yes", response.getHeader("X-Druid-SQL-Header-Included")); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( Collections.singletonList("EXPR$0"), Collections.singletonList(null), @@ -1044,12 +1044,12 @@ public void testArrayLinesResultFormat() throws Exception final Pair pair = doPostRaw( new SqlQuery(query, ResultFormat.ARRAYLINES, false, false, false, null, null) ); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final List lines = Splitter.on('\n').splitToList(response); - Assert.assertEquals(4, lines.size()); - Assert.assertEquals( + Assertions.assertEquals(4, lines.size()); + Assertions.assertEquals( Arrays.asList( "2000-01-01T00:00:00.000Z", "", @@ -1063,7 +1063,7 @@ public void testArrayLinesResultFormat() throws Exception ), JSON_MAPPER.readValue(lines.get(0), List.class) ); - Assert.assertEquals( + Assertions.assertEquals( Arrays.asList( "2000-01-02T00:00:00.000Z", "10.1", @@ -1077,8 +1077,8 @@ public void testArrayLinesResultFormat() throws Exception ), JSON_MAPPER.readValue(lines.get(1), List.class) ); - Assert.assertEquals("", lines.get(2)); - Assert.assertEquals("", lines.get(3)); + Assertions.assertEquals("", lines.get(2)); + Assertions.assertEquals("", lines.get(3)); } @Test @@ -1088,15 +1088,15 @@ public void testArrayLinesResultFormatWithHeader() throws Exception final Pair pair = doPostRaw( new SqlQuery(query, ResultFormat.ARRAYLINES, true, true, true, null, null) ); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final List lines = Splitter.on('\n').splitToList(response); - Assert.assertEquals(7, lines.size()); - Assert.assertEquals(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(0), List.class)); - Assert.assertEquals(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(1), List.class)); - Assert.assertEquals(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(2), List.class)); - Assert.assertEquals( + Assertions.assertEquals(7, lines.size()); + Assertions.assertEquals(EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(0), List.class)); + Assertions.assertEquals(EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(1), List.class)); + Assertions.assertEquals(EXPECTED_SQL_TYPES_FOR_RESULT_FORMAT_TESTS, JSON_MAPPER.readValue(lines.get(2), List.class)); + Assertions.assertEquals( Arrays.asList( "2000-01-01T00:00:00.000Z", "", @@ -1110,7 +1110,7 @@ public void testArrayLinesResultFormatWithHeader() throws Exception ), JSON_MAPPER.readValue(lines.get(3), List.class) ); - Assert.assertEquals( + Assertions.assertEquals( Arrays.asList( "2000-01-02T00:00:00.000Z", "10.1", @@ -1124,8 +1124,8 @@ public void testArrayLinesResultFormatWithHeader() throws Exception ), JSON_MAPPER.readValue(lines.get(4), List.class) ); - Assert.assertEquals("", lines.get(5)); - Assert.assertEquals("", lines.get(6)); + Assertions.assertEquals("", lines.get(5)); + Assertions.assertEquals("", lines.get(6)); } @Test @@ -1135,15 +1135,15 @@ public void testArrayLinesResultFormatWithHeader_nullColumnType() throws Excepti final Pair pair = doPostRaw( new SqlQuery(query, ResultFormat.ARRAYLINES, true, true, true, null, null) ); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final List lines = Splitter.on('\n').splitToList(response); - Assert.assertEquals(6, lines.size()); - Assert.assertEquals(Collections.singletonList("EXPR$0"), JSON_MAPPER.readValue(lines.get(0), List.class)); - Assert.assertEquals(Collections.singletonList(null), JSON_MAPPER.readValue(lines.get(1), List.class)); - Assert.assertEquals(Collections.singletonList("ROW"), JSON_MAPPER.readValue(lines.get(2), List.class)); - Assert.assertEquals( + Assertions.assertEquals(6, lines.size()); + Assertions.assertEquals(Collections.singletonList("EXPR$0"), JSON_MAPPER.readValue(lines.get(0), List.class)); + Assertions.assertEquals(Collections.singletonList(null), JSON_MAPPER.readValue(lines.get(1), List.class)); + Assertions.assertEquals(Collections.singletonList("ROW"), JSON_MAPPER.readValue(lines.get(2), List.class)); + Assertions.assertEquals( Collections.singletonList( Arrays.asList( 1, @@ -1152,8 +1152,8 @@ public void testArrayLinesResultFormatWithHeader_nullColumnType() throws Excepti ), JSON_MAPPER.readValue(lines.get(3), List.class) ); - Assert.assertEquals("", lines.get(4)); - Assert.assertEquals("", lines.get(5)); + Assertions.assertEquals("", lines.get(4)); + Assertions.assertEquals("", lines.get(5)); } @Test @@ -1165,7 +1165,7 @@ public void testObjectResultFormat() throws Exception (k, v) -> "EXPR$8".equals(k) || ("dim2".equals(k) && v.toString().isEmpty()) ? null : v ); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap .builder() @@ -1208,7 +1208,7 @@ public void testObjectLinesResultFormat() throws Exception final Pair pair = doPostRaw( new SqlQuery(query, ResultFormat.OBJECTLINES, false, false, false, null, null) ); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final Function, Map> transformer = m -> { return Maps.transformEntries( @@ -1218,8 +1218,8 @@ public void testObjectLinesResultFormat() throws Exception }; final List lines = Splitter.on('\n').splitToList(response); - Assert.assertEquals(4, lines.size()); - Assert.assertEquals( + Assertions.assertEquals(4, lines.size()); + Assertions.assertEquals( transformer.apply( ImmutableMap .builder() @@ -1236,7 +1236,7 @@ public void testObjectLinesResultFormat() throws Exception ), JSON_MAPPER.readValue(lines.get(0), Object.class) ); - Assert.assertEquals( + Assertions.assertEquals( transformer.apply( ImmutableMap .builder() @@ -1253,8 +1253,8 @@ public void testObjectLinesResultFormat() throws Exception ), JSON_MAPPER.readValue(lines.get(1), Object.class) ); - Assert.assertEquals("", lines.get(2)); - Assert.assertEquals("", lines.get(3)); + Assertions.assertEquals("", lines.get(2)); + Assertions.assertEquals("", lines.get(3)); } @Test @@ -1263,7 +1263,7 @@ public void testObjectLinesResultFormatWithMinimalHeader() throws Exception final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2"; final Pair pair = doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, false, false, null, null)); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final Function, Map> transformer = m -> Maps.transformEntries( m, @@ -1276,9 +1276,9 @@ public void testObjectLinesResultFormatWithMinimalHeader() throws Exception expectedHeader.put(column, null); } - Assert.assertEquals(5, lines.size()); - Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class)); - Assert.assertEquals( + Assertions.assertEquals(5, lines.size()); + Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class)); + Assertions.assertEquals( transformer.apply( ImmutableMap .builder() @@ -1295,7 +1295,7 @@ public void testObjectLinesResultFormatWithMinimalHeader() throws Exception ), JSON_MAPPER.readValue(lines.get(1), Object.class) ); - Assert.assertEquals( + Assertions.assertEquals( transformer.apply( ImmutableMap .builder() @@ -1312,8 +1312,8 @@ public void testObjectLinesResultFormatWithMinimalHeader() throws Exception ), JSON_MAPPER.readValue(lines.get(2), Object.class) ); - Assert.assertEquals("", lines.get(3)); - Assert.assertEquals("", lines.get(4)); + Assertions.assertEquals("", lines.get(3)); + Assertions.assertEquals("", lines.get(4)); } @Test @@ -1322,7 +1322,7 @@ public void testObjectLinesResultFormatWithFullHeader() throws Exception final String query = "SELECT *, CASE dim2 WHEN '' THEN dim2 END FROM foo LIMIT 2"; final Pair pair = doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, true, true, null, null)); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final Function, Map> transformer = m -> Maps.transformEntries( m, @@ -1341,9 +1341,9 @@ public void testObjectLinesResultFormatWithFullHeader() throws Exception ); } - Assert.assertEquals(5, lines.size()); - Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class)); - Assert.assertEquals( + Assertions.assertEquals(5, lines.size()); + Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class)); + Assertions.assertEquals( transformer.apply( ImmutableMap .builder() @@ -1360,7 +1360,7 @@ public void testObjectLinesResultFormatWithFullHeader() throws Exception ), JSON_MAPPER.readValue(lines.get(1), Object.class) ); - Assert.assertEquals( + Assertions.assertEquals( transformer.apply( ImmutableMap .builder() @@ -1377,8 +1377,8 @@ public void testObjectLinesResultFormatWithFullHeader() throws Exception ), JSON_MAPPER.readValue(lines.get(2), Object.class) ); - Assert.assertEquals("", lines.get(3)); - Assert.assertEquals("", lines.get(4)); + Assertions.assertEquals("", lines.get(3)); + Assertions.assertEquals("", lines.get(4)); } @Test @@ -1387,7 +1387,7 @@ public void testObjectLinesResultFormatWithFullHeader_nullColumnType() throws Ex final String query = "SELECT (1, 2) FROM INFORMATION_SCHEMA.COLUMNS LIMIT 1"; final Pair pair = doPostRaw(new SqlQuery(query, ResultFormat.OBJECTLINES, true, true, true, null, null)); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final List lines = Splitter.on('\n').splitToList(response); @@ -1396,9 +1396,9 @@ public void testObjectLinesResultFormatWithFullHeader_nullColumnType() throws Ex typeMap.put(ObjectWriter.SQL_TYPE_HEADER_NAME, "ROW"); final Map expectedHeader = ImmutableMap.of("EXPR$0", typeMap); - Assert.assertEquals(4, lines.size()); - Assert.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class)); - Assert.assertEquals( + Assertions.assertEquals(4, lines.size()); + Assertions.assertEquals(expectedHeader, JSON_MAPPER.readValue(lines.get(0), Object.class)); + Assertions.assertEquals( ImmutableMap .builder() .put("EXPR$0", Arrays.asList(1, 2)) @@ -1406,8 +1406,8 @@ public void testObjectLinesResultFormatWithFullHeader_nullColumnType() throws Ex JSON_MAPPER.readValue(lines.get(1), Object.class) ); - Assert.assertEquals("", lines.get(2)); - Assert.assertEquals("", lines.get(3)); + Assertions.assertEquals("", lines.get(2)); + Assertions.assertEquals("", lines.get(3)); } @Test @@ -1417,11 +1417,11 @@ public void testCsvResultFormat() throws Exception final Pair pair = doPostRaw( new SqlQuery(query, ResultFormat.CSV, false, false, false, null, null) ); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final List lines = Splitter.on('\n').splitToList(response); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( "2000-01-01T00:00:00.000Z,,a,\"[\"\"a\"\",\"\"b\"\"]\",1,1.0,1.0,\"\"\"AQAAAEAAAA==\"\"\",", "2000-01-02T00:00:00.000Z,10.1,,\"[\"\"b\"\",\"\"c\"\"]\",1,2.0,2.0,\"\"\"AQAAAQAAAAHNBA==\"\"\",", @@ -1439,11 +1439,11 @@ public void testCsvResultFormatWithHeaders() throws Exception final Pair pair = doPostRaw( new SqlQuery(query, ResultFormat.CSV, true, true, true, null, null) ); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final List lines = Splitter.on('\n').splitToList(response); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( String.join(",", EXPECTED_COLUMNS_FOR_RESULT_FORMAT_TESTS), String.join(",", EXPECTED_TYPES_FOR_RESULT_FORMAT_TESTS), @@ -1464,11 +1464,11 @@ public void testCsvResultFormatWithHeaders_nullColumnType() throws Exception final Pair pair = doPostRaw( new SqlQuery(query, ResultFormat.CSV, true, true, true, null, null) ); - Assert.assertNull(pair.lhs); + Assertions.assertNull(pair.lhs); final String response = pair.rhs; final List lines = Splitter.on('\n').splitToList(response); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( "EXPR$0", "", @@ -1499,7 +1499,7 @@ public void testExplainCountStar() throws Exception ) ).rhs; - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of( ImmutableMap.of( "PLAN", @@ -1528,8 +1528,8 @@ public void testCannotParse() throws Exception errorResponse, "Incorrect syntax near the keyword 'FROM' at line 1, column 1" ); - Assert.assertEquals(0, testRequestLogger.getSqlQueryLogs().size()); // Invalid queries are not logged - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertEquals(0, testRequestLogger.getSqlQueryLogs().size()); // Invalid queries are not logged + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } @Test @@ -1545,9 +1545,9 @@ public void testCannotValidate() throws Exception "Column 'dim4' not found in any table" ); checkSqlRequestLog(false); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -1557,7 +1557,7 @@ public void testCannotConvert() throws Exception final SqlQuery unsupportedQuery = createSimpleQueryWithId("id", "SELECT dim1 FROM druid.foo ORDER BY dim1"); ErrorResponse exception = postSyncForException(unsupportedQuery, Status.BAD_REQUEST.getStatusCode()); - Assert.assertTrue((Boolean) req.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED)); + Assertions.assertTrue((Boolean) req.getAttribute(AuthConfig.DRUID_AUTHORIZATION_CHECKED)); validateErrorResponse( exception, @@ -1568,9 +1568,9 @@ public void testCannotConvert() throws Exception + "[SQL query requires ordering a table by non-time column [[dim1]], which is not supported.]" ); checkSqlRequestLog(false); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } /** @@ -1592,9 +1592,9 @@ public void testCannotConvert_InvalidSQL() throws Exception "Aggregation [MAX] does not support type [STRING], column [v0]" ); checkSqlRequestLog(false); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -1618,7 +1618,7 @@ public void testResourceLimitExceeded() throws Exception ResourceLimitExceededException.class.getName(), "" ); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } private void failOnExecute(String errorMessage) @@ -1647,7 +1647,7 @@ public void testUnsupportedQueryThrowsException() throws Exception ); validateInvalidSqlError(exception, "Incorrect syntax near the keyword 'TO'"); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } @Test @@ -1672,8 +1672,8 @@ public void testErrorResponseReturnSameQueryIdWhenSetInContext() // This is checked in the common method that returns the response, but checking it again just protects // from changes there breaking the checks, so doesn't hurt. assertStatusAndCommonHeaders(response, DruidException.Category.INVALID_INPUT.getExpectedStatus()); - Assert.assertEquals(queryId, getHeader(response, QueryResource.QUERY_ID_RESPONSE_HEADER)); - Assert.assertEquals(queryId, getHeader(response, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER)); + Assertions.assertEquals(queryId, getHeader(response, QueryResource.QUERY_ID_RESPONSE_HEADER)); + Assertions.assertEquals(queryId, getHeader(response, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER)); } @Test @@ -1694,8 +1694,8 @@ public void testErrorResponseReturnNoQueryIdWhenNotSetInContext() final Response response = resource.doPost(sqlQuery, req); // Query ID won't be set, but we can look for other aspects of the response that we expect. - Assert.assertEquals(DruidException.Category.INVALID_INPUT.getExpectedStatus(), response.getStatus()); - Assert.assertEquals("application/json", getContentType(response)); + Assertions.assertEquals(DruidException.Category.INVALID_INPUT.getExpectedStatus(), response.getStatus()); + Assertions.assertEquals("application/json", getContentType(response)); } @Test @@ -1749,7 +1749,7 @@ public ErrorResponseTransformStrategy getErrorResponseTransformStrategy() "org.apache.druid.query.QueryUnsupportedException", "This will be supported in Druid 9999" ); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); } /** @@ -1785,9 +1785,9 @@ public void testAssertionErrorThrowsErrorWithFilterResponse() throws Exception .invalidSqlInput() .expectMessageIs("Calcite assertion violated: [not a literal: assertion_error()]") ); - Assert.assertTrue(lifecycleManager.getAll("id").isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll("id").isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -1864,8 +1864,8 @@ public void testTooManyRequestsAfterTotalLaning() throws Exception Response response = (Response) futures.get(i).get(); assertStatusAndCommonHeaders(response, 429); QueryException interruped = deserializeResponse(response, QueryException.class); - Assert.assertEquals(QueryException.QUERY_CAPACITY_EXCEEDED_ERROR_CODE, interruped.getErrorCode()); - Assert.assertEquals( + Assertions.assertEquals(QueryException.QUERY_CAPACITY_EXCEEDED_ERROR_CODE, interruped.getErrorCode()); + Assertions.assertEquals( QueryCapacityExceededException.makeLaneErrorMessage(HiLoQueryLaningStrategy.LOW, 2), interruped.getMessage() ); @@ -1873,17 +1873,17 @@ public void testTooManyRequestsAfterTotalLaning() throws Exception } else { MockHttpServletResponse response = (MockHttpServletResponse) futures.get(i).get(); assertStatusAndCommonHeaders(response, 200); - Assert.assertEquals( + Assertions.assertEquals( ImmutableList.of(ImmutableMap.of("cnt", 6, "TheFoo", "foo")), deserializeResponse(response, Object.class) ); success++; } } - Assert.assertEquals(2, success); - Assert.assertEquals(1, limited); - Assert.assertEquals(3, testRequestLogger.getSqlQueryLogs().size()); - Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); + Assertions.assertEquals(2, success); + Assertions.assertEquals(1, limited); + Assertions.assertEquals(3, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 3); Map codeFrequencies = stubServiceEmitter.getMetricEvents("sqlQuery/time").stream() .map(event -> event.toMap()) @@ -1892,7 +1892,7 @@ public void testTooManyRequestsAfterTotalLaning() throws Exception code -> code, Collectors.counting() )); - Assert.assertEquals(Map.of(200, 2L, 429, 1L), codeFrequencies); + Assertions.assertEquals(Map.of(200, 2L, 429, 1L), codeFrequencies); } @Test @@ -1925,9 +1925,9 @@ public void testQueryTimeoutException() throws Exception QueryTimeoutException.class.getName(), "" ); - Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(504, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(504, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -1945,13 +1945,13 @@ public void testCancelBetweenValidateAndPlan() throws Exception makeRegularUserReq() ) ); - Assert.assertTrue(validateAndAuthorizeLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); - Assert.assertTrue(lifecycleAddLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); + Assertions.assertTrue(validateAndAuthorizeLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); + Assertions.assertTrue(lifecycleAddLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel()); planLatch.countDown(); - Assert.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus()); + Assertions.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus()); - Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); Response queryResponse = future.get(); assertStatusAndCommonHeaders(queryResponse, Status.INTERNAL_SERVER_ERROR.getStatusCode()); @@ -1964,7 +1964,7 @@ public void testCancelBetweenValidateAndPlan() throws Exception "" ); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -1981,12 +1981,12 @@ public void testCancelBetweenPlanAndExecute() throws Exception makeRegularUserReq() ) ); - Assert.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); + Assertions.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel()); execLatch.countDown(); - Assert.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus()); + Assertions.assertEquals(Status.ACCEPTED.getStatusCode(), cancelResponse.getStatus()); - Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); Response queryResponse = future.get(); assertStatusAndCommonHeaders(queryResponse, Status.INTERNAL_SERVER_ERROR.getStatusCode()); @@ -1994,7 +1994,7 @@ public void testCancelBetweenPlanAndExecute() throws Exception ErrorResponse exception = deserializeResponse(queryResponse, ErrorResponse.class); validateLegacyQueryExceptionErrorResponse(exception, "Query cancelled", null, ""); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(500, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -2011,15 +2011,15 @@ public void testCancelInvalidQuery() throws Exception makeRegularUserReq() ) ); - Assert.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); + Assertions.assertTrue(planLatch.await(WAIT_TIMEOUT_SECS, TimeUnit.SECONDS)); Response cancelResponse = resource.cancelQuery("invalidQuery", makeRequestForCancel()); - Assert.assertEquals(Status.NOT_FOUND.getStatusCode(), cancelResponse.getStatus()); + Assertions.assertEquals(Status.NOT_FOUND.getStatusCode(), cancelResponse.getStatus()); - Assert.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty()); + Assertions.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty()); execLatch.countDown(); MockHttpServletResponse queryResponse = future.get(); - Assert.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus()); + Assertions.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus()); } @Test @@ -2036,15 +2036,15 @@ public void testCancelForbidden() throws Exception makeSuperUserReq() ) ); - Assert.assertTrue(planLatch.await(3, TimeUnit.SECONDS)); + Assertions.assertTrue(planLatch.await(3, TimeUnit.SECONDS)); Response cancelResponse = resource.cancelQuery(sqlQueryId, makeRequestForCancel()); - Assert.assertEquals(Status.FORBIDDEN.getStatusCode(), cancelResponse.getStatus()); + Assertions.assertEquals(Status.FORBIDDEN.getStatusCode(), cancelResponse.getStatus()); - Assert.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty()); + Assertions.assertFalse(lifecycleManager.getAll(sqlQueryId).isEmpty()); execLatch.countDown(); MockHttpServletResponse queryResponse = future.get(); - Assert.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus()); + Assertions.assertEquals(Status.OK.getStatusCode(), queryResponse.getStatus()); } @Test @@ -2076,9 +2076,9 @@ public void testQueryContextException() throws Exception "2000'" ); checkSqlRequestLog(false); - Assert.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); + Assertions.assertTrue(lifecycleManager.getAll(sqlQueryId).isEmpty()); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } @Test @@ -2096,7 +2096,7 @@ public void testQueryContextKeyNotAllowed() throws Exception ); checkSqlRequestLog(false); stubServiceEmitter.verifyEmitted("sqlQuery/time", 1); - Assert.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); + Assertions.assertEquals(400, stubServiceEmitter.getMetricEvents("sqlQuery/time").get(0).toMap().get(DruidMetrics.STATUS_CODE)); } private void checkSqlRequestLog(boolean success) @@ -2107,21 +2107,21 @@ private void checkSqlRequestLog(boolean success) @SuppressWarnings("unchecked") private void checkSqlRequestLog(boolean success, String user) { - Assert.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); + Assertions.assertEquals(1, testRequestLogger.getSqlQueryLogs().size()); final Map stats = testRequestLogger.getSqlQueryLogs().get(0).getQueryStats().getStats(); final Map queryContext = (Map) testRequestLogger.getSqlQueryLogs() .get(0) .getSqlQueryContext(); - Assert.assertEquals(success, stats.get("success")); - Assert.assertEquals(user, stats.get("identity")); - Assert.assertTrue(stats.containsKey("sqlQuery/time")); - Assert.assertTrue(stats.containsKey("sqlQuery/planningTimeMs")); - Assert.assertTrue(queryContext.containsKey(QueryContexts.CTX_SQL_QUERY_ID)); + Assertions.assertEquals(success, stats.get("success")); + Assertions.assertEquals(user, stats.get("identity")); + Assertions.assertTrue(stats.containsKey("sqlQuery/time")); + Assertions.assertTrue(stats.containsKey("sqlQuery/planningTimeMs")); + Assertions.assertTrue(queryContext.containsKey(QueryContexts.CTX_SQL_QUERY_ID)); if (success) { - Assert.assertTrue(stats.containsKey("sqlQuery/bytes")); + Assertions.assertTrue(stats.containsKey("sqlQuery/bytes")); } else { - Assert.assertTrue(stats.containsKey("exception")); + Assertions.assertTrue(stats.containsKey("exception")); } } @@ -2188,7 +2188,7 @@ private MockHttpServletResponse postForAsyncResponse(SqlQuery query, MockHttpSer final Object explicitQueryId = query.getContext().get("queryId"); final Object explicitSqlQueryId = query.getContext().get("sqlQueryId"); - Assert.assertNull(resource.doPost(query, req)); + Assertions.assertNull(resource.doPost(query, req)); final Object actualQueryId = response.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER); final Object actualSqlQueryId = response.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER); @@ -2199,10 +2199,10 @@ private MockHttpServletResponse postForAsyncResponse(SqlQuery query, MockHttpSer private void assertStatusAndCommonHeaders(MockHttpServletResponse queryResponse, int statusCode) { - Assert.assertEquals(statusCode, queryResponse.getStatus()); - Assert.assertEquals("application/json", queryResponse.getContentType()); - Assert.assertNotNull(queryResponse.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER)); - Assert.assertNotNull(queryResponse.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER)); + Assertions.assertEquals(statusCode, queryResponse.getStatus()); + Assertions.assertEquals("application/json", queryResponse.getContentType()); + Assertions.assertNotNull(queryResponse.getHeader(QueryResource.QUERY_ID_RESPONSE_HEADER)); + Assertions.assertNotNull(queryResponse.getHeader(SqlResource.SQL_QUERY_ID_RESPONSE_HEADER)); } private T deserializeResponse(MockHttpServletResponse resp, Class clazz) throws IOException @@ -2270,10 +2270,10 @@ private Object getHeader(Response resp, String header) private void assertStatusAndCommonHeaders(Response queryResponse, int statusCode) { - Assert.assertEquals(statusCode, queryResponse.getStatus()); - Assert.assertEquals("application/json", getContentType(queryResponse)); - Assert.assertNotNull(getHeader(queryResponse, QueryResource.QUERY_ID_RESPONSE_HEADER)); - Assert.assertNotNull(getHeader(queryResponse, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER)); + Assertions.assertEquals(statusCode, queryResponse.getStatus()); + Assertions.assertEquals("application/json", getContentType(queryResponse)); + Assertions.assertNotNull(getHeader(queryResponse, QueryResource.QUERY_ID_RESPONSE_HEADER)); + Assertions.assertNotNull(getHeader(queryResponse, SqlResource.SQL_QUERY_ID_RESPONSE_HEADER)); } private void validateQueryIds( @@ -2285,19 +2285,19 @@ private void validateQueryIds( { if (explicitQueryId == null) { if (null != explicitSqlQueryId) { - Assert.assertEquals(explicitSqlQueryId, actualQueryId); - Assert.assertEquals(explicitSqlQueryId, actualSqlQueryId); + Assertions.assertEquals(explicitSqlQueryId, actualQueryId); + Assertions.assertEquals(explicitSqlQueryId, actualSqlQueryId); } else { - Assert.assertNotNull(actualQueryId); - Assert.assertNotNull(actualSqlQueryId); + Assertions.assertNotNull(actualQueryId); + Assertions.assertNotNull(actualSqlQueryId); } } else { if (explicitSqlQueryId == null) { - Assert.assertEquals(explicitQueryId, actualQueryId); - Assert.assertEquals(explicitQueryId, actualSqlQueryId); + Assertions.assertEquals(explicitQueryId, actualQueryId); + Assertions.assertEquals(explicitQueryId, actualSqlQueryId); } else { - Assert.assertEquals(explicitQueryId, actualQueryId); - Assert.assertEquals(explicitSqlQueryId, actualSqlQueryId); + Assertions.assertEquals(explicitQueryId, actualQueryId); + Assertions.assertEquals(explicitSqlQueryId, actualSqlQueryId); } } } @@ -2496,17 +2496,17 @@ private DruidException validateErrorResponse( String messageContainsString ) { - Assert.assertNotNull(errorResponse); + Assertions.assertNotNull(errorResponse); DruidException exception = errorResponse.getUnderlyingException(); - Assert.assertEquals(errorCode, exception.getErrorCode()); - Assert.assertEquals(targetPersona, exception.getTargetPersona()); - Assert.assertEquals(category, exception.getCategory()); + Assertions.assertEquals(errorCode, exception.getErrorCode()); + Assertions.assertEquals(targetPersona, exception.getTargetPersona()); + Assertions.assertEquals(category, exception.getCategory()); if (messageContainsString == null) { - Assert.assertNull(exception.getMessage()); + Assertions.assertNull(exception.getMessage()); } else { - assertThat(exception.getMessage(), CoreMatchers.containsString(messageContainsString)); + Assertions.assertTrue(exception.getMessage().contains(messageContainsString)); } return exception; @@ -2518,7 +2518,7 @@ private DruidException validateInvalidSqlError( ) { final DruidException exception = validateInvalidInputError(response, containsString); - Assert.assertEquals("sql", exception.getContextValue("sourceType")); + Assertions.assertEquals("sql", exception.getContextValue("sourceType")); return exception; } @@ -2550,8 +2550,8 @@ private DruidException validateLegacyQueryExceptionErrorResponse( messageContainsString ); - Assert.assertEquals(legacyCode, exception.getContextValue("legacyErrorCode")); - Assert.assertEquals(errorClass, exception.getContextValue("errorClass")); + Assertions.assertEquals(legacyCode, exception.getContextValue("legacyErrorCode")); + Assertions.assertEquals(errorClass, exception.getContextValue("errorClass")); return exception; }