You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@druid.apache.org by fr...@apache.org on 2026/08/13 02:44:05 UTC

(druid) branch master updated: test(indexing-service): migrate Overlord tests to JUnit 5 (#19922)

This is an automated email from the ASF dual-hosted git repository.

FrankChen021 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/druid.git


The following commit(s) were added to refs/heads/master by this push:
     new c72a9144b8c test(indexing-service): migrate Overlord tests to JUnit 5 (#19922)
c72a9144b8c is described below

commit c72a9144b8cb829541dc23221f530e072e65133f
Author: Frank Chen <fr...@outlook.com>
AuthorDate: Thu Aug 13 10:43:59 2026 +0800

    test(indexing-service): migrate Overlord tests to JUnit 5 (#19922)
    
    * test(indexing-service): migrate Overlord tests to JUnit 5
    
    * fix(indexing-service): remove stale checked exception declaration
    
    * test(indexing): address overlord API review feedback
    
    * test(indexing): use TempDir for overlord tests
    
    * fix(indexing): remove unused task status local
    
    * fix(indexing): avoid duplicate Derby fixture lifecycle
---
 .../indexing/overlord/ForkingTaskRunnerTest.java   | 142 +++----
 .../indexing/overlord/GlobalTaskLockboxTest.java   | 417 +++++++++++----------
 .../overlord/HeapMemoryTaskStorageTest.java        |  24 +-
 .../indexing/overlord/ImmutableWorkerInfoTest.java |  22 +-
 .../IndexerMetadataStorageAdapterTest.java         |  56 +--
 .../druid/indexing/overlord/PortFinderTest.java    |  12 +-
 .../druid/indexing/overlord/RealtimeishTask.java   |  18 +-
 .../overlord/SingleTaskBackgroundRunnerTest.java   |  43 +--
 .../druid/indexing/overlord/TaskLifecycleTest.java | 231 ++++++------
 .../overlord/TaskLockBoxConcurrencyTest.java       |  74 ++--
 .../indexing/overlord/TaskLockConfigTest.java      |  26 +-
 .../overlord/TaskQueueConcurrencyTest.java         | 119 +++---
 .../indexing/overlord/TaskQueueScaleTest.java      |  59 +--
 .../druid/indexing/overlord/TaskQueueTest.java     | 174 +++++----
 .../indexing/overlord/TaskRunnerUtilsTest.java     |  22 +-
 .../indexing/overlord/TaskStorageUtilsTest.java    |  10 +-
 .../indexing/overlord/ThreadingTaskRunnerTest.java |  22 +-
 .../overlord/WorkerTaskRunnerQueryAdpaterTest.java |  62 +--
 .../PendingTaskBasedProvisioningStrategyTest.java  | 130 +++----
 .../SimpleProvisioningStrategyTest.java            |  74 ++--
 .../config/ForkingTaskRunnerConfigTest.java        |  53 ++-
 .../duty/KillUnreferencedIndexingStateTest.java    |  60 +--
 .../overlord/duty/OverlordDutyExecutorTest.java    |   2 +-
 .../duty/TaskLogAutoCleanerConfigTest.java         |  20 +-
 .../overlord/duty/TaskLogAutoCleanerTest.java      |  12 +-
 .../overlord/duty/UnusedSegmentsKillerTest.java    |  69 ++--
 .../overlord/hrtr/HttpRemoteTaskRunnerTest.java    | 279 +++++++-------
 .../indexing/overlord/hrtr/WorkerHolderTest.java   |  64 ++--
 .../http/OverlordCompactionResourceTest.java       |  82 ++--
 .../http/OverlordDataSourcesResourceTest.java      |  44 +--
 .../overlord/http/OverlordRedirectInfoTest.java    |  30 +-
 .../overlord/http/OverlordResourceTest.java        | 224 ++++++-----
 .../druid/indexing/overlord/http/OverlordTest.java |  52 +--
 .../OverlordSecurityResourceFilterTest.java        |  28 +-
 .../security/SupervisorResourceFilterTest.java     |  20 +-
 .../http/security/TaskResourceFilterTest.java      |  12 +-
 .../sampler/CsvInputSourceSamplerTest.java         |  22 +-
 .../overlord/sampler/IndexTaskSamplerSpecTest.java |  23 +-
 .../sampler/InputSourceSamplerDiscoveryTest.java   |  40 +-
 .../overlord/sampler/InputSourceSamplerTest.java   | 141 ++++---
 .../overlord/sampler/SamplerResourceTest.java      |  12 +-
 .../overlord/sampler/SamplerResponseTest.java      |   6 +-
 ...butionWithAffinityWorkerSelectStrategyTest.java |  20 +-
 ...onWithCategorySpecWorkerSelectStrategyTest.java |  36 +-
 .../EqualDistributionWorkerSelectStrategyTest.java |  24 +-
 ...pacityWithAffinityWorkerSelectStrategyTest.java |  18 +-
 ...tyWithCategorySpecWorkerSelectStrategyTest.java |  36 +-
 .../setup/JavaScriptWorkerSelectStrategyTest.java  |  39 +-
 .../overlord/setup/WorkerCategorySpecTest.java     |  12 +-
 .../overlord/supervisor/NoticesQueueTest.java      |  28 +-
 .../overlord/supervisor/SupervisorManagerTest.java | 392 +++++++++----------
 .../autoscaler/LagBasedAutoScalerConfigTest.java   | 148 ++++----
 52 files changed, 1938 insertions(+), 1847 deletions(-)

diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ForkingTaskRunnerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ForkingTaskRunnerTest.java
index aff352ce31e..5917d7f72c3 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ForkingTaskRunnerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ForkingTaskRunnerTest.java
@@ -53,10 +53,9 @@ import org.apache.druid.server.log.StartupLoggingConfig;
 import org.apache.druid.tasklogs.NoopTaskLogs;
 import org.assertj.core.util.Lists;
 import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 
 import javax.annotation.Nonnull;
 import java.io.ByteArrayInputStream;
@@ -72,25 +71,35 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class ForkingTaskRunnerTest
 {
 
   private static final ObjectMapper OBJECT_MAPPER = new DefaultObjectMapper();
-  @Rule
-  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @TempDir
+  private File temporaryFolder;
+
+  private File newTempFolder()
+  {
+    return FileUtils.createTempDirInLocation(temporaryFolder.toPath(), "tmp");
+  }
+
+  private File newTempFile() throws IOException
+  {
+    return File.createTempFile("tmp", null, temporaryFolder);
+  }
 
   @Test
   public void testGetJavaCommandPrefersRunJavaScriptWhenPresent() throws IOException
   {
-    final File workingDir = temporaryFolder.newFolder();
+    final File workingDir = newTempFolder();
     final File binDir = new File(workingDir, "bin");
     FileUtils.mkdirp(binDir);
-    Assert.assertTrue(new File(binDir, "run-java").createNewFile());
+    Assertions.assertTrue(new File(binDir, "run-java").createNewFile());
 
     // No configured command (null) and the run-java script is present -> use it.
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "bin/run-java",
         ForkingTaskRunner.getJavaCommand(null, workingDir)
     );
@@ -99,8 +108,8 @@ public class ForkingTaskRunnerTest
   @Test
   public void testGetJavaCommandFallsBackToJavaWhenScriptAbsent() throws IOException
   {
-    final File workingDir = temporaryFolder.newFolder();
-    Assert.assertEquals(
+    final File workingDir = newTempFolder();
+    Assertions.assertEquals(
         "java",
         ForkingTaskRunner.getJavaCommand(null, workingDir)
     );
@@ -109,35 +118,38 @@ public class ForkingTaskRunnerTest
   @Test
   public void testConfigHasNoDefaultJavaCommand()
   {
-    Assert.assertNull(new ForkingTaskRunnerConfig().getJavaCommand());
+    Assertions.assertNull(new ForkingTaskRunnerConfig().getJavaCommand());
   }
 
   @Test
   public void testGetJavaCommandRespectsExplicitOverride() throws IOException
   {
-    final File workingDir = temporaryFolder.newFolder();
+    final File workingDir = newTempFolder();
     final File binDir = new File(workingDir, "bin");
     FileUtils.mkdirp(binDir);
-    Assert.assertTrue(new File(binDir, "run-java").createNewFile());
+    Assertions.assertTrue(new File(binDir, "run-java").createNewFile());
 
     // An explicit, non-default javaCommand must be used verbatim even when the run-java script is present.
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "/opt/jdk/bin/java",
         ForkingTaskRunner.getJavaCommand("/opt/jdk/bin/java", workingDir)
     );
   }
 
   // This tests the test to make sure the test fails when it should.
-  @Test(expected = AssertionError.class)
+  @Test
   public void testPatternMatcherFailureForJavaOptions()
   {
-    checkValues(new String[]{"not quoted has space"});
+    Assertions.assertThrows(
+        AssertionError.class,
+        () -> checkValues(new String[]{"not quoted has space"})
+    );
   }
 
-  @Test(expected = AssertionError.class)
+  @Test
   public void testPatternMatcherFailureForSpaceOnlyJavaOptions()
   {
-    checkValues(new String[]{" "});
+    Assertions.assertThrows(AssertionError.class, () -> checkValues(new String[]{" "}));
   }
 
   @Test
@@ -189,7 +201,7 @@ public class ForkingTaskRunnerTest
   @Test
   public void testEmpty()
   {
-    Assert.assertTrue(ImmutableList.copyOf(new QuotableWhiteSpaceSplitter("")).isEmpty());
+    Assertions.assertTrue(ImmutableList.copyOf(new QuotableWhiteSpaceSplitter("")).isEmpty());
   }
 
   @Test
@@ -207,7 +219,7 @@ public class ForkingTaskRunnerTest
   @Test
   public void testOmitEmpty()
   {
-    Assert.assertTrue(
+    Assertions.assertTrue(
         ImmutableList.copyOf(
             new QuotableWhiteSpaceSplitter(" \t     \t\t\t\t \n\n \f\f \n\f\r\t")
         ).isEmpty()
@@ -280,11 +292,11 @@ public class ForkingTaskRunnerTest
       @Override
       int waitForTaskProcessToComplete(Task task, ProcessHolder processHolder, File logFile, File reportsFile)
       {
-        Assert.assertEquals(1L, (long) this.getWorkerUsedTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCapacity(), (long) this.getWorkerTotalTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCapacity() - 1, (long) this.getWorkerIdleTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCategory(), this.getWorkerCategory());
-        Assert.assertEquals(workerConfig.getVersion(), this.getWorkerVersion());
+        Assertions.assertEquals(1L, (long) this.getWorkerUsedTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCapacity(), (long) this.getWorkerTotalTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCapacity() - 1, (long) this.getWorkerIdleTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCategory(), this.getWorkerCategory());
+        Assertions.assertEquals(workerConfig.getVersion(), this.getWorkerVersion());
         // Emulate task process failure
         return 1;
       }
@@ -297,8 +309,8 @@ public class ForkingTaskRunnerTest
         "Task execution process exited unsuccessfully with code[1]. See middleManager logs for more details.",
         status.getErrorMsg()
     );
-    Assert.assertEquals(1L, (long) forkingTaskRunner.getWorkerFailedTaskCount());
-    Assert.assertEquals(0L, (long) forkingTaskRunner.getWorkerSuccessfulTaskCount());
+    Assertions.assertEquals(1L, (long) forkingTaskRunner.getWorkerFailedTaskCount());
+    Assertions.assertEquals(0L, (long) forkingTaskRunner.getWorkerSuccessfulTaskCount());
   }
 
   @Test
@@ -306,7 +318,7 @@ public class ForkingTaskRunnerTest
   {
     ObjectMapper mapper = new DefaultObjectMapper();
     Task task = NoopTask.create();
-    File file = temporaryFolder.newFolder();
+    File file = newTempFolder();
     TaskConfig taskConfig = makeDefaultTaskConfigBuilder()
         .setBaseTaskDir(file.toString())
         .build();
@@ -342,11 +354,11 @@ public class ForkingTaskRunnerTest
       @Override
       int waitForTaskProcessToComplete(Task task, ProcessHolder processHolder, File logFile, File reportsFile)
       {
-        Assert.assertEquals(1L, (long) this.getWorkerUsedTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCapacity(), (long) this.getWorkerTotalTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCapacity() - 1, (long) this.getWorkerIdleTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCategory(), this.getWorkerCategory());
-        Assert.assertEquals(workerConfig.getVersion(), this.getWorkerVersion());
+        Assertions.assertEquals(1L, (long) this.getWorkerUsedTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCapacity(), (long) this.getWorkerTotalTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCapacity() - 1, (long) this.getWorkerIdleTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCategory(), this.getWorkerCategory());
+        Assertions.assertEquals(workerConfig.getVersion(), this.getWorkerVersion());
         return 0;
       }
     };
@@ -354,9 +366,9 @@ public class ForkingTaskRunnerTest
     forkingTaskRunner.setNumProcessorsPerTask();
     final TaskStatus status = forkingTaskRunner.run(task).get();
     assertEquals(TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertNull(status.getErrorMsg());
-    Assert.assertEquals(0L, (long) forkingTaskRunner.getWorkerFailedTaskCount());
-    Assert.assertEquals(1L, (long) forkingTaskRunner.getWorkerSuccessfulTaskCount());
+    Assertions.assertNull(status.getErrorMsg());
+    Assertions.assertEquals(0L, (long) forkingTaskRunner.getWorkerFailedTaskCount());
+    Assertions.assertEquals(1L, (long) forkingTaskRunner.getWorkerSuccessfulTaskCount());
   }
 
   @Test
@@ -364,7 +376,7 @@ public class ForkingTaskRunnerTest
   {
     ObjectMapper mapper = new DefaultObjectMapper();
     Task task = NoopTask.create();
-    File file = temporaryFolder.newFolder();
+    File file = newTempFolder();
     TaskConfig taskConfig = makeDefaultTaskConfigBuilder()
         .setBaseTaskDir(file.toString())
         .build();
@@ -413,7 +425,7 @@ public class ForkingTaskRunnerTest
   @Test
   public void testGettingTheNextAttemptDir() throws IOException
   {
-    File file = temporaryFolder.newFolder();
+    File file = newTempFolder();
     TaskConfig taskConfig = makeDefaultTaskConfigBuilder()
         .setBaseTaskDir(file.toString())
         .build();
@@ -436,34 +448,34 @@ public class ForkingTaskRunnerTest
   @Test
   public void testGettingTheNextAttemptDirFailsIfAttemptDirectoryCannotBeCreated() throws IOException
   {
-    final File taskDir = temporaryFolder.newFile();
+    final File taskDir = newTempFile();
     final File attemptDir = new File(taskDir, "attempt");
 
-    final ISE exception = Assert.assertThrows(
+    final ISE exception = Assertions.assertThrows(
         ISE.class,
         () -> ForkingTaskRunner.getNextAttemptID(taskDir)
     );
 
-    Assert.assertEquals("Error creating directory[" + attemptDir + "]", exception.getMessage());
-    Assert.assertTrue(exception.getCause() instanceof IOException);
+    Assertions.assertEquals("Error creating directory[" + attemptDir + "]", exception.getMessage());
+    Assertions.assertTrue(exception.getCause() instanceof IOException);
   }
 
   @Test
   public void testGettingTheNextAttemptDirFailsIfAttemptCannotBeCreated() throws IOException
   {
-    final File taskDir = temporaryFolder.newFolder();
+    final File taskDir = newTempFolder();
     final File attemptDir = new File(taskDir, "attempt");
     FileUtils.mkdirp(attemptDir);
     final File attempt = new File(attemptDir, "1");
-    Assert.assertTrue(attempt.createNewFile());
+    Assertions.assertTrue(attempt.createNewFile());
 
-    final ISE exception = Assert.assertThrows(
+    final ISE exception = Assertions.assertThrows(
         ISE.class,
         () -> ForkingTaskRunner.getNextAttemptID(taskDir)
     );
 
-    Assert.assertEquals("Error creating directory[" + attempt + "]", exception.getMessage());
-    Assert.assertTrue(exception.getCause() instanceof IOException);
+    Assertions.assertEquals("Error creating directory[" + attempt + "]", exception.getMessage());
+    Assertions.assertTrue(exception.getCause() instanceof IOException);
   }
 
   @Test
@@ -521,8 +533,8 @@ public class ForkingTaskRunnerTest
 
     forkingTaskRunner.setNumProcessorsPerTask();
     forkingTaskRunner.run(task).get();
-    Assert.assertTrue(xmxJavaOptsArrayIndex.get() > xmxJavaOptsIndex.get());
-    Assert.assertTrue(xmxJavaOptsIndex.get() >= 0);
+    Assertions.assertTrue(xmxJavaOptsArrayIndex.get() > xmxJavaOptsIndex.get());
+    Assertions.assertTrue(xmxJavaOptsIndex.get() >= 0);
   }
 
   @Test
@@ -566,24 +578,24 @@ public class ForkingTaskRunnerTest
       @Override
       int waitForTaskProcessToComplete(Task task, ProcessHolder processHolder, File logFile, File reportsFile)
       {
-        Assert.assertEquals(1L, (long) this.getWorkerUsedTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCapacity(), (long) this.getWorkerTotalTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCapacity() - 1, (long) this.getWorkerIdleTaskSlotCount());
-        Assert.assertEquals(workerConfig.getCategory(), this.getWorkerCategory());
-        Assert.assertEquals(workerConfig.getVersion(), this.getWorkerVersion());
+        Assertions.assertEquals(1L, (long) this.getWorkerUsedTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCapacity(), (long) this.getWorkerTotalTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCapacity() - 1, (long) this.getWorkerIdleTaskSlotCount());
+        Assertions.assertEquals(workerConfig.getCategory(), this.getWorkerCategory());
+        Assertions.assertEquals(workerConfig.getVersion(), this.getWorkerVersion());
         return 1;
       }
     };
 
     forkingTaskRunner.setNumProcessorsPerTask();
-    ExecutionException e = Assert.assertThrows(ExecutionException.class, () -> forkingTaskRunner.run(task).get());
-    Assert.assertTrue(e.getMessage().endsWith(ForkingTaskRunnerConfig.JAVA_OPTS_ARRAY_PROPERTY
+    ExecutionException e = Assertions.assertThrows(ExecutionException.class, () -> forkingTaskRunner.run(task).get());
+    Assertions.assertTrue(e.getMessage().endsWith(ForkingTaskRunnerConfig.JAVA_OPTS_ARRAY_PROPERTY
                                               + " in context of task: "
                                               + task.getId()
                                               + " must be an array of strings.")
     );
-    Assert.assertEquals(0L, (long) forkingTaskRunner.getWorkerFailedTaskCount());
-    Assert.assertEquals(0L, (long) forkingTaskRunner.getWorkerSuccessfulTaskCount());
+    Assertions.assertEquals(0L, (long) forkingTaskRunner.getWorkerFailedTaskCount());
+    Assertions.assertEquals(0L, (long) forkingTaskRunner.getWorkerSuccessfulTaskCount());
   }
 
   @Test
@@ -594,8 +606,8 @@ public class ForkingTaskRunnerTest
 
     TaskStorageDirTracker dirTracker = TaskStorageDirTracker.fromBaseDirs(
         ImmutableList.of(
-            temporaryFolder.newFolder().getAbsoluteFile(),
-            temporaryFolder.newFolder().getAbsoluteFile()
+            newTempFolder().getAbsoluteFile(),
+            newTempFolder().getAbsoluteFile()
         ),
         1,
         100_000_000_000_000_000L
@@ -622,7 +634,7 @@ public class ForkingTaskRunnerTest
     forkingTaskRunner.setNumProcessorsPerTask();
     Task task = NoopTask.create();
     forkingTaskRunner.run(task);
-    Assert.assertTrue(forkingTaskRunner.restore().isEmpty());
+    Assertions.assertTrue(forkingTaskRunner.restore().isEmpty());
   }
 
   @Test
@@ -747,9 +759,9 @@ public class ForkingTaskRunnerTest
 
     forkingTaskRunner.setNumProcessorsPerTask();
     final TaskStatus status = forkingTaskRunner.run(task).get();
-    Assert.assertNotNull(observedCommandRef);
+    Assertions.assertNotNull(observedCommandRef);
     final List<String> observedCommand = observedCommandRef.get();
-    Assert.assertTrue(observedCommand.contains("-Ddruid.server.priority=2"));
+    Assertions.assertTrue(observedCommand.contains("-Ddruid.server.priority=2"));
     assertEquals(TaskState.SUCCESS, status.getStatusCode());
   }
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/GlobalTaskLockboxTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/GlobalTaskLockboxTest.java
index c2f9f25e689..9e0251a090d 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/GlobalTaskLockboxTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/GlobalTaskLockboxTest.java
@@ -30,7 +30,6 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import org.apache.druid.common.utils.IdUtils;
-import org.apache.druid.error.ExceptionMatcher;
 import org.apache.druid.indexer.TaskStatus;
 import org.apache.druid.indexing.common.LockGranularity;
 import org.apache.druid.indexing.common.SegmentLock;
@@ -77,12 +76,12 @@ import org.apache.druid.timeline.partition.NumberedShardSpec;
 import org.apache.druid.timeline.partition.PartialShardSpec;
 import org.apache.druid.timeline.partition.PartitionIds;
 import org.easymock.EasyMock;
-import org.hamcrest.MatcherAssert;
 import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -97,8 +96,7 @@ import java.util.stream.Collectors;
 
 public class GlobalTaskLockboxTest
 {
-  @Rule
-  public final TestDerbyConnector.DerbyConnectorRule derby = new TestDerbyConnector.DerbyConnectorRule();
+  private final TestDerbyConnector.DerbyConnectorRule derby = new TestDerbyConnector.DerbyConnectorRule();
 
   private TaskStorage taskStorage;
   private IndexerMetadataStorageCoordinator metadataStorageCoordinator;
@@ -110,9 +108,10 @@ public class GlobalTaskLockboxTest
   private final int MEDIUM_PRIORITY = 10;
   private final int LOW_PRIORITY = 5;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
+    derby.before();
     final ObjectMapper objectMapper = TestHelper.makeJsonMapper();
     objectMapper.registerSubtypes(NumberedShardSpec.class, HashBasedNumberedShardSpec.class);
     final TestDerbyConnector derbyConnector = derby.getConnector();
@@ -161,6 +160,12 @@ public class GlobalTaskLockboxTest
     validator = new TaskLockboxValidator(lockbox, taskStorage);
   }
 
+  @AfterEach
+  public void teardown()
+  {
+    derby.after();
+  }
+
   private LockResult acquireTimeChunkLock(TaskLockType lockType, Task task, Interval interval, long timeoutMs)
       throws InterruptedException
   {
@@ -193,10 +198,13 @@ public class GlobalTaskLockboxTest
     );
   }
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void testLockForInactiveTask() throws InterruptedException
   {
-    acquireTimeChunkLock(TaskLockType.EXCLUSIVE, NoopTask.create(), Intervals.of("2015-01-01/2015-01-02"));
+    Assertions.assertThrows(
+        IllegalStateException.class,
+        () -> acquireTimeChunkLock(TaskLockType.EXCLUSIVE, NoopTask.create(), Intervals.of("2015-01-01/2015-01-02"))
+    );
   }
 
   @Test
@@ -205,11 +213,11 @@ public class GlobalTaskLockboxTest
     final Task task = NoopTask.create();
     lockbox.add(task);
     lockbox.remove(task);
-    ISE exception = Assert.assertThrows(
+    ISE exception = Assertions.assertThrows(
         ISE.class,
         () -> acquireTimeChunkLock(TaskLockType.EXCLUSIVE, task, Intervals.of("2015-01-01/2015-01-02"))
     );
-    Assert.assertTrue(exception.getMessage().contains("Unable to grant lock to inactive Task"));
+    Assertions.assertTrue(exception.getMessage().contains("Unable to grant lock to inactive Task"));
   }
 
   @Test
@@ -271,32 +279,32 @@ public class GlobalTaskLockboxTest
 
     lockbox.add(lowPriorityTask);
     lockbox.add(lowPriorityTask2);
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval1).isOk());
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, lowPriorityTask, interval2).isOk());
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, lowPriorityTask2, interval2).isOk());
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval3).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval1).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, lowPriorityTask, interval2).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, lowPriorityTask2, interval2).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval3).isOk());
 
     lockbox.add(highPiorityTask);
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, highPiorityTask, interval1).isOk());
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval2).isOk());
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval3).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, highPiorityTask, interval1).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval2).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval3).isOk());
 
-    Assert.assertTrue(lockbox.findLocksForTask(lowPriorityTask).stream().allMatch(TaskLock::isRevoked));
-    Assert.assertTrue(lockbox.findLocksForTask(lowPriorityTask2).stream().allMatch(TaskLock::isRevoked));
+    Assertions.assertTrue(lockbox.findLocksForTask(lowPriorityTask).stream().allMatch(TaskLock::isRevoked));
+    Assertions.assertTrue(lockbox.findLocksForTask(lowPriorityTask2).stream().allMatch(TaskLock::isRevoked));
 
     lockbox.remove(lowPriorityTask);
     lockbox.remove(lowPriorityTask2);
     lockbox.remove(highPiorityTask);
 
     lockbox.add(highPiorityTask);
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval1).isOk());
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, highPiorityTask, interval2).isOk());
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval3).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval1).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, highPiorityTask, interval2).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPiorityTask, interval3).isOk());
 
     lockbox.add(lowPriorityTask);
-    Assert.assertFalse(tryTimeChunkLock(TaskLockType.SHARED, lowPriorityTask, interval1).isOk());
-    Assert.assertFalse(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval2).isOk());
-    Assert.assertFalse(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval3).isOk());
+    Assertions.assertFalse(tryTimeChunkLock(TaskLockType.SHARED, lowPriorityTask, interval1).isOk());
+    Assertions.assertFalse(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval2).isOk());
+    Assertions.assertFalse(tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval3).isOk());
   }
 
   @Test
@@ -304,24 +312,27 @@ public class GlobalTaskLockboxTest
   {
     Task task = NoopTask.create();
     lockbox.add(task);
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, task, Intervals.of("2015-01-01/2015-01-03")).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, task, Intervals.of("2015-01-01/2015-01-03")).isOk());
 
     // try to take lock for task 2 for overlapping interval
     Task task2 = NoopTask.create();
     lockbox.add(task2);
-    Assert.assertFalse(tryTimeChunkLock(TaskLockType.EXCLUSIVE, task2, Intervals.of("2015-01-01/2015-01-02")).isOk());
+    Assertions.assertFalse(tryTimeChunkLock(TaskLockType.EXCLUSIVE, task2, Intervals.of("2015-01-01/2015-01-02")).isOk());
 
     // task 1 unlocks the lock
     lockbox.remove(task);
 
     // Now task2 should be able to get the lock
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, task2, Intervals.of("2015-01-01/2015-01-02")).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, task2, Intervals.of("2015-01-01/2015-01-02")).isOk());
   }
 
-  @Test(expected = IllegalStateException.class)
+  @Test
   public void testTryLockForInactiveTask()
   {
-    Assert.assertFalse(tryTimeChunkLock(TaskLockType.EXCLUSIVE, NoopTask.create(), Intervals.of("2015-01-01/2015-01-02")).isOk());
+    Assertions.assertThrows(
+        IllegalStateException.class,
+        () -> tryTimeChunkLock(TaskLockType.EXCLUSIVE, NoopTask.create(), Intervals.of("2015-01-01/2015-01-02"))
+    );
   }
 
   @Test
@@ -331,11 +342,11 @@ public class GlobalTaskLockboxTest
     lockbox.add(task);
     lockbox.remove(task);
 
-    ISE exception = Assert.assertThrows(
+    ISE exception = Assertions.assertThrows(
         ISE.class,
         () -> tryTimeChunkLock(TaskLockType.EXCLUSIVE, task, Intervals.of("2015-01-01/2015-01-02"))
     );
-    Assert.assertTrue(exception.getMessage().contains("Unable to grant lock to inactive Task"));
+    Assertions.assertTrue(exception.getMessage().contains("Unable to grant lock to inactive Task"));
   }
 
   @Test
@@ -346,8 +357,8 @@ public class GlobalTaskLockboxTest
 
     lockbox.add(task1);
     lockbox.add(task2);
-    Assert.assertTrue(acquireTimeChunkLock(TaskLockType.EXCLUSIVE, task1, Intervals.of("2015-01-01/2015-01-02"), 5000).isOk());
-    Assert.assertFalse(acquireTimeChunkLock(TaskLockType.EXCLUSIVE, task2, Intervals.of("2015-01-01/2015-01-15"), 1000).isOk());
+    Assertions.assertTrue(acquireTimeChunkLock(TaskLockType.EXCLUSIVE, task1, Intervals.of("2015-01-01/2015-01-02"), 5000).isOk());
+    Assertions.assertFalse(acquireTimeChunkLock(TaskLockType.EXCLUSIVE, task2, Intervals.of("2015-01-01/2015-01-15"), 1000).isOk());
   }
 
   @Test
@@ -360,7 +371,7 @@ public class GlobalTaskLockboxTest
       final Task task = NoopTask.create();
       taskStorage.insert(task, TaskStatus.running(task.getId()));
       originalBox.add(task);
-      Assert.assertTrue(
+      Assertions.assertTrue(
           originalBox.tryLock(
               task,
               new TimeChunkLockRequest(
@@ -380,14 +391,14 @@ public class GlobalTaskLockboxTest
     final GlobalTaskLockbox newBox = new GlobalTaskLockbox(taskStorage, metadataStorageCoordinator);
     newBox.syncFromStorage();
 
-    Assert.assertEquals(originalBox.getAllLocks(), newBox.getAllLocks());
-    Assert.assertEquals(originalBox.getActiveTasks(), newBox.getActiveTasks());
+    Assertions.assertEquals(originalBox.getAllLocks(), newBox.getAllLocks());
+    Assertions.assertEquals(originalBox.getActiveTasks(), newBox.getActiveTasks());
 
     final List<TaskLock> afterLocksInStorage = taskStorage.getActiveTasks().stream()
                                                           .flatMap(task -> taskStorage.getLocks(task.getId()).stream())
                                                           .collect(Collectors.toList());
 
-    Assert.assertEquals(beforeLocksInStorage, afterLocksInStorage);
+    Assertions.assertEquals(beforeLocksInStorage, afterLocksInStorage);
   }
 
   @Test
@@ -411,7 +422,7 @@ public class GlobalTaskLockboxTest
                                                           .flatMap(t -> taskStorage.getLocks(t.getId()).stream())
                                                           .collect(Collectors.toList());
 
-    Assert.assertEquals(beforeLocksInStorage, afterLocksInStorage);
+    Assertions.assertEquals(beforeLocksInStorage, afterLocksInStorage);
   }
 
   @Test
@@ -442,7 +453,7 @@ public class GlobalTaskLockboxTest
                                                           .flatMap(t -> taskStorage.getLocks(t.getId()).stream())
                                                           .collect(Collectors.toList());
 
-    Assert.assertEquals(beforeLocksInStorage, afterLocksInStorage);
+    Assertions.assertEquals(beforeLocksInStorage, afterLocksInStorage);
   }
 
   @Test
@@ -464,8 +475,8 @@ public class GlobalTaskLockboxTest
 
     final GlobalTaskLockbox lockbox = new GlobalTaskLockbox(taskStorage, metadataStorageCoordinator);
     TaskLockboxSyncResult result = lockbox.syncFromStorage();
-    Assert.assertEquals(1, result.getTasksToFail().size());
-    Assert.assertTrue(result.getTasksToFail().contains(task));
+    Assertions.assertEquals(1, result.getTasksToFail().size());
+    Assertions.assertTrue(result.getTasksToFail().contains(task));
   }
 
   @Test
@@ -524,8 +535,8 @@ public class GlobalTaskLockboxTest
     theBox.syncFromStorage();
     loadedBox.syncFromStorage();
 
-    Assert.assertEquals(1, tasks.size());
-    Assert.assertEquals(2, tasksFromLoaded.size());
+    Assertions.assertEquals(1, tasks.size());
+    Assertions.assertEquals(2, tasksFromLoaded.size());
   }
 
   @Test
@@ -537,13 +548,13 @@ public class GlobalTaskLockboxTest
     final Task task1 = NoopTask.ofPriority(10);
     taskStorage.insert(task1, TaskStatus.running(task1.getId()));
     originalBox.add(task1);
-    Assert.assertTrue(originalBox.tryLock(task1, new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, task1, Intervals.of("2017/2018"), null)).isOk());
+    Assertions.assertTrue(originalBox.tryLock(task1, new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, task1, Intervals.of("2017/2018"), null)).isOk());
 
     // task2 revokes task1
     final Task task2 = NoopTask.ofPriority(100);
     taskStorage.insert(task2, TaskStatus.running(task2.getId()));
     originalBox.add(task2);
-    Assert.assertTrue(originalBox.tryLock(task2, new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, task2, Intervals.of("2017/2018"), null)).isOk());
+    Assertions.assertTrue(originalBox.tryLock(task2, new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, task2, Intervals.of("2017/2018"), null)).isOk());
 
     final Map<String, List<TaskLock>> beforeLocksInStorage = taskStorage
         .getActiveTasks()
@@ -551,12 +562,12 @@ public class GlobalTaskLockboxTest
         .collect(Collectors.toMap(Task::getId, task -> taskStorage.getLocks(task.getId())));
 
     final List<TaskLock> task1Locks = beforeLocksInStorage.get(task1.getId());
-    Assert.assertEquals(1, task1Locks.size());
-    Assert.assertTrue(task1Locks.get(0).isRevoked());
+    Assertions.assertEquals(1, task1Locks.size());
+    Assertions.assertTrue(task1Locks.get(0).isRevoked());
 
     final List<TaskLock> task2Locks = beforeLocksInStorage.get(task1.getId());
-    Assert.assertEquals(1, task2Locks.size());
-    Assert.assertTrue(task2Locks.get(0).isRevoked());
+    Assertions.assertEquals(1, task2Locks.size());
+    Assertions.assertTrue(task2Locks.get(0).isRevoked());
 
     final GlobalTaskLockbox newBox = new GlobalTaskLockbox(taskStorage, metadataStorageCoordinator);
     newBox.syncFromStorage();
@@ -565,7 +576,7 @@ public class GlobalTaskLockboxTest
                                                          .flatMap(task -> taskStorage.getLocks(task.getId()).stream())
                                                          .collect(Collectors.toSet());
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         beforeLocksInStorage.values().stream().flatMap(Collection::stream).collect(Collectors.toSet()),
         afterLocksInStorage
     );
@@ -577,9 +588,9 @@ public class GlobalTaskLockboxTest
     final Interval interval = Intervals.of("2017-01-01/2017-01-02");
     final Task task = NoopTask.create();
     lockbox.add(task);
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, task, interval).isOk());
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, task, interval).isOk());
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.doInCriticalSection(
             task,
             Collections.singleton(interval),
@@ -595,9 +606,9 @@ public class GlobalTaskLockboxTest
     final Task task = NoopTask.create();
     lockbox.add(task);
     final TaskLock lock = tryTimeChunkLock(TaskLockType.EXCLUSIVE, task, interval).getTaskLock();
-    Assert.assertNotNull(lock);
+    Assertions.assertNotNull(lock);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.doInCriticalSection(
             task,
             Collections.singleton(interval),
@@ -614,9 +625,9 @@ public class GlobalTaskLockboxTest
     final Task task = NoopTask.create();
     lockbox.add(task);
     final TaskLock lock = tryTimeChunkLock(TaskLockType.EXCLUSIVE, task, interval).getTaskLock();
-    Assert.assertNotNull(lock);
+    Assertions.assertNotNull(lock);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.doInCriticalSection(
             task,
             Collections.singleton(interval),
@@ -633,16 +644,16 @@ public class GlobalTaskLockboxTest
       final Task task = NoopTask.create();
       lockbox.add(task);
       taskStorage.insert(task, TaskStatus.running(task.getId()));
-      Assert.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, task, interval).isOk());
+      Assertions.assertTrue(tryTimeChunkLock(TaskLockType.SHARED, task, interval).isOk());
     }
 
     final Task highPriorityTask = NoopTask.ofPriority(100);
     lockbox.add(highPriorityTask);
     taskStorage.insert(highPriorityTask, TaskStatus.running(highPriorityTask.getId()));
     final TaskLock lock = tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPriorityTask, interval).getTaskLock();
-    Assert.assertNotNull(lock);
+    Assertions.assertNotNull(lock);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.doInCriticalSection(
             highPriorityTask,
             Collections.singleton(interval),
@@ -663,11 +674,11 @@ public class GlobalTaskLockboxTest
     taskStorage.insert(highPriorityTask, TaskStatus.running(highPriorityTask.getId()));
 
     final TaskLock lowPriorityLock = tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval).getTaskLock();
-    Assert.assertNotNull(lowPriorityLock);
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPriorityTask, interval).isOk());
-    Assert.assertTrue(Iterables.getOnlyElement(lockbox.findLocksForTask(lowPriorityTask)).isRevoked());
+    Assertions.assertNotNull(lowPriorityLock);
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPriorityTask, interval).isOk());
+    Assertions.assertTrue(Iterables.getOnlyElement(lockbox.findLocksForTask(lowPriorityTask)).isRevoked());
 
-    Assert.assertFalse(
+    Assertions.assertFalse(
         lockbox.doInCriticalSection(
             lowPriorityTask,
             Collections.singleton(interval),
@@ -676,7 +687,8 @@ public class GlobalTaskLockboxTest
     );
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testAcquireLockAfterRevoked() throws InterruptedException
   {
     final Interval interval = Intervals.of("2017-01-01/2017-01-02");
@@ -688,17 +700,17 @@ public class GlobalTaskLockboxTest
     taskStorage.insert(highPriorityTask, TaskStatus.running(highPriorityTask.getId()));
 
     final TaskLock lowPriorityLock = acquireTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval).getTaskLock();
-    Assert.assertNotNull(lowPriorityLock);
-    Assert.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPriorityTask, interval).isOk());
-    Assert.assertTrue(Iterables.getOnlyElement(lockbox.findLocksForTask(lowPriorityTask)).isRevoked());
+    Assertions.assertNotNull(lowPriorityLock);
+    Assertions.assertTrue(tryTimeChunkLock(TaskLockType.EXCLUSIVE, highPriorityTask, interval).isOk());
+    Assertions.assertTrue(Iterables.getOnlyElement(lockbox.findLocksForTask(lowPriorityTask)).isRevoked());
 
     lockbox.unlock(highPriorityTask, interval);
 
     // Acquire again
     final LockResult lockResult = acquireTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval);
-    Assert.assertFalse(lockResult.isOk());
-    Assert.assertTrue(lockResult.isRevoked());
-    Assert.assertTrue(Iterables.getOnlyElement(lockbox.findLocksForTask(lowPriorityTask)).isRevoked());
+    Assertions.assertFalse(lockResult.isOk());
+    Assertions.assertTrue(lockResult.isRevoked());
+    Assertions.assertTrue(Iterables.getOnlyElement(lockbox.findLocksForTask(lowPriorityTask)).isRevoked());
   }
 
   @Test
@@ -712,7 +724,7 @@ public class GlobalTaskLockboxTest
       lowPriorityTasks.add(task);
       taskStorage.insert(task, TaskStatus.running(task.getId()));
       lockbox.add(task);
-      Assert.assertTrue(
+      Assertions.assertTrue(
           tryTimeChunkLock(
               TaskLockType.EXCLUSIVE,
               task,
@@ -727,7 +739,7 @@ public class GlobalTaskLockboxTest
       highPriorityTasks.add(task);
       taskStorage.insert(task, TaskStatus.running(task.getId()));
       lockbox.add(task);
-      Assert.assertTrue(
+      Assertions.assertTrue(
           tryTimeChunkLock(
               TaskLockType.EXCLUSIVE,
               task,
@@ -737,12 +749,12 @@ public class GlobalTaskLockboxTest
     }
 
     for (int i = 0; i < 4; i++) {
-      Assert.assertTrue(taskStorage.getLocks(lowPriorityTasks.get(i).getId()).stream().allMatch(TaskLock::isRevoked));
-      Assert.assertFalse(taskStorage.getLocks(highPriorityTasks.get(i).getId()).stream().allMatch(TaskLock::isRevoked));
+      Assertions.assertTrue(taskStorage.getLocks(lowPriorityTasks.get(i).getId()).stream().allMatch(TaskLock::isRevoked));
+      Assertions.assertFalse(taskStorage.getLocks(highPriorityTasks.get(i).getId()).stream().allMatch(TaskLock::isRevoked));
     }
 
     for (int i = 4; i < 8; i++) {
-      Assert.assertFalse(taskStorage.getLocks(lowPriorityTasks.get(i).getId()).stream().allMatch(TaskLock::isRevoked));
+      Assertions.assertFalse(taskStorage.getLocks(lowPriorityTasks.get(i).getId()).stream().allMatch(TaskLock::isRevoked));
     }
 
     for (int i = 0; i < 4; i++) {
@@ -763,7 +775,7 @@ public class GlobalTaskLockboxTest
       );
     }
 
-    Assert.assertTrue(lockbox.getAllLocks().isEmpty());
+    Assertions.assertTrue(lockbox.getAllLocks().isEmpty());
   }
 
   @Test
@@ -777,7 +789,7 @@ public class GlobalTaskLockboxTest
     lockbox.add(lowPriorityTask);
     lockbox.add(highPriorityTask);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         tryTimeChunkLock(
             TaskLockType.EXCLUSIVE,
             lowPriorityTask,
@@ -785,7 +797,7 @@ public class GlobalTaskLockboxTest
         ).isOk()
     );
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         tryTimeChunkLock(
             TaskLockType.EXCLUSIVE,
             highPriorityTask,
@@ -798,18 +810,18 @@ public class GlobalTaskLockboxTest
         Intervals.of("2018-12-16T09:00:00/2018-12-16T09:30:00")
     );
 
-    Assert.assertTrue(highLockPosse.isPresent());
-    Assert.assertTrue(highLockPosse.get().containsTask(highPriorityTask));
-    Assert.assertFalse(highLockPosse.get().getTaskLock().isRevoked());
+    Assertions.assertTrue(highLockPosse.isPresent());
+    Assertions.assertTrue(highLockPosse.get().containsTask(highPriorityTask));
+    Assertions.assertFalse(highLockPosse.get().getTaskLock().isRevoked());
 
     final Optional<TaskLockbox.TaskLockPosse> lowLockPosse = lockbox.getOnlyTaskLockPosseContainingInterval(
         lowPriorityTask,
         Intervals.of("2018-12-16T09:00:00/2018-12-16T10:00:00")
     );
 
-    Assert.assertTrue(lowLockPosse.isPresent());
-    Assert.assertTrue(lowLockPosse.get().containsTask(lowPriorityTask));
-    Assert.assertTrue(lowLockPosse.get().getTaskLock().isRevoked());
+    Assertions.assertTrue(lowLockPosse.isPresent());
+    Assertions.assertTrue(lowLockPosse.get().containsTask(lowPriorityTask));
+    Assertions.assertTrue(lowLockPosse.get().getTaskLock().isRevoked());
   }
 
   @Test
@@ -827,18 +839,18 @@ public class GlobalTaskLockboxTest
             3
         )
     );
-    Assert.assertTrue(lockResult.isOk());
-    Assert.assertNull(lockResult.getNewSegmentId());
-    Assert.assertTrue(lockResult.getTaskLock() instanceof SegmentLock);
+    Assertions.assertTrue(lockResult.isOk());
+    Assertions.assertNull(lockResult.getNewSegmentId());
+    Assertions.assertTrue(lockResult.getTaskLock() instanceof SegmentLock);
     final SegmentLock segmentLock = (SegmentLock) lockResult.getTaskLock();
-    Assert.assertEquals(TaskLockType.EXCLUSIVE, segmentLock.getType());
-    Assert.assertEquals(task.getGroupId(), segmentLock.getGroupId());
-    Assert.assertEquals(task.getDataSource(), segmentLock.getDataSource());
-    Assert.assertEquals(Intervals.of("2015-01-01/2015-01-02"), segmentLock.getInterval());
-    Assert.assertEquals("v1", segmentLock.getVersion());
-    Assert.assertEquals(3, segmentLock.getPartitionId());
-    Assert.assertEquals(task.getPriority(), segmentLock.getPriority().intValue());
-    Assert.assertFalse(segmentLock.isRevoked());
+    Assertions.assertEquals(TaskLockType.EXCLUSIVE, segmentLock.getType());
+    Assertions.assertEquals(task.getGroupId(), segmentLock.getGroupId());
+    Assertions.assertEquals(task.getDataSource(), segmentLock.getDataSource());
+    Assertions.assertEquals(Intervals.of("2015-01-01/2015-01-02"), segmentLock.getInterval());
+    Assertions.assertEquals("v1", segmentLock.getVersion());
+    Assertions.assertEquals(3, segmentLock.getPartitionId());
+    Assertions.assertEquals(task.getPriority(), segmentLock.getPriority().intValue());
+    Assertions.assertFalse(segmentLock.isRevoked());
   }
 
   @Test
@@ -850,7 +862,7 @@ public class GlobalTaskLockboxTest
     final Task task2 = NoopTask.create();
     lockbox.add(task2);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task1,
             new SpecificSegmentLockRequest(
@@ -863,7 +875,7 @@ public class GlobalTaskLockboxTest
         ).isOk()
     );
 
-    Assert.assertFalse(
+    Assertions.assertFalse(
         lockbox.tryLock(
             task2,
             new TimeChunkLockRequest(
@@ -887,7 +899,7 @@ public class GlobalTaskLockboxTest
     lockbox.add(task2);
     taskStorage.insert(task2, TaskStatus.running(task2.getId()));
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task1,
             new SpecificSegmentLockRequest(
@@ -900,7 +912,7 @@ public class GlobalTaskLockboxTest
         ).isOk()
     );
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task2,
             new TimeChunkLockRequest(
@@ -922,8 +934,8 @@ public class GlobalTaskLockboxTest
             3
         )
     );
-    Assert.assertFalse(resultOfTask1.isOk());
-    Assert.assertTrue(resultOfTask1.isRevoked());
+    Assertions.assertFalse(resultOfTask1.isOk());
+    Assertions.assertTrue(resultOfTask1.isRevoked());
   }
 
   @Test
@@ -935,7 +947,7 @@ public class GlobalTaskLockboxTest
     final Task task2 = NoopTask.create();
     lockbox.add(task2);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task1,
             new SpecificSegmentLockRequest(
@@ -948,7 +960,7 @@ public class GlobalTaskLockboxTest
         ).isOk()
     );
 
-    Assert.assertFalse(
+    Assertions.assertFalse(
         lockbox.tryLock(
             task2,
             new SpecificSegmentLockRequest(
@@ -971,7 +983,7 @@ public class GlobalTaskLockboxTest
     final Task task2 = NoopTask.create();
     lockbox.add(task2);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task1,
             new SpecificSegmentLockRequest(
@@ -984,7 +996,7 @@ public class GlobalTaskLockboxTest
         ).isOk()
     );
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task2,
             new SpecificSegmentLockRequest(
@@ -1007,7 +1019,7 @@ public class GlobalTaskLockboxTest
     final Task task2 = NoopTask.create();
     lockbox.add(task2);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task1,
             new SpecificSegmentLockRequest(
@@ -1020,7 +1032,7 @@ public class GlobalTaskLockboxTest
         ).isOk()
     );
 
-    Assert.assertFalse(
+    Assertions.assertFalse(
         lockbox.tryLock(
             task2,
             new SpecificSegmentLockRequest(
@@ -1043,12 +1055,12 @@ public class GlobalTaskLockboxTest
     allocateSegmentsAndAssert(task, "seq2", 2, new NumberedOverwritePartialShardSpec(0, 3, (short) 1));
 
     final List<TaskLock> locks = lockbox.findLocksForTask(task);
-    Assert.assertEquals(5, locks.size());
+    Assertions.assertEquals(5, locks.size());
     int expectedPartitionId = 0;
     for (TaskLock lock : locks) {
-      Assert.assertTrue(lock instanceof SegmentLock);
+      Assertions.assertTrue(lock instanceof SegmentLock);
       final SegmentLock segmentLock = (SegmentLock) lock;
-      Assert.assertEquals(expectedPartitionId++, segmentLock.getPartitionId());
+      Assertions.assertEquals(expectedPartitionId++, segmentLock.getPartitionId());
       if (expectedPartitionId == 3) {
         expectedPartitionId = PartitionIds.NON_ROOT_GEN_START_PARTITION_ID;
       }
@@ -1092,19 +1104,19 @@ public class GlobalTaskLockboxTest
       LockResult result
   )
   {
-    Assert.assertTrue(result.isOk());
-    Assert.assertNotNull(result.getTaskLock());
-    Assert.assertTrue(result.getTaskLock() instanceof SegmentLock);
-    Assert.assertNotNull(result.getNewSegmentId());
+    Assertions.assertTrue(result.isOk());
+    Assertions.assertNotNull(result.getTaskLock());
+    Assertions.assertTrue(result.getTaskLock() instanceof SegmentLock);
+    Assertions.assertNotNull(result.getNewSegmentId());
     final SegmentLock segmentLock = (SegmentLock) result.getTaskLock();
     final SegmentIdWithShardSpec segmentId = result.getNewSegmentId();
 
-    Assert.assertEquals(lockRequest.getType(), segmentLock.getType());
-    Assert.assertEquals(lockRequest.getGroupId(), segmentLock.getGroupId());
-    Assert.assertEquals(lockRequest.getDataSource(), segmentLock.getDataSource());
-    Assert.assertEquals(lockRequest.getInterval(), segmentLock.getInterval());
-    Assert.assertEquals(lockRequest.getPartialShardSpec().getShardSpecClass(), segmentId.getShardSpec().getClass());
-    Assert.assertEquals(lockRequest.getPriority(), segmentLock.getPriority().intValue());
+    Assertions.assertEquals(lockRequest.getType(), segmentLock.getType());
+    Assertions.assertEquals(lockRequest.getGroupId(), segmentLock.getGroupId());
+    Assertions.assertEquals(lockRequest.getDataSource(), segmentLock.getDataSource());
+    Assertions.assertEquals(lockRequest.getInterval(), segmentLock.getInterval());
+    Assertions.assertEquals(lockRequest.getPartialShardSpec().getShardSpecClass(), segmentId.getShardSpec().getClass());
+    Assertions.assertEquals(lockRequest.getPriority(), segmentLock.getPriority().intValue());
   }
 
   @Test
@@ -1135,10 +1147,10 @@ public class GlobalTaskLockboxTest
     TaskLockbox.TaskLockPosse taskLockPosse2 = new TaskLockbox.TaskLockPosse(taskLock2);
     TaskLockbox.TaskLockPosse taskLockPosse3 = new TaskLockbox.TaskLockPosse(taskLock1);
 
-    Assert.assertNotEquals(taskLockPosse1, null);
-    Assert.assertNotEquals(null, taskLockPosse1);
-    Assert.assertNotEquals(taskLockPosse1, taskLockPosse2);
-    Assert.assertEquals(taskLockPosse1, taskLockPosse3);
+    Assertions.assertNotEquals(taskLockPosse1, null);
+    Assertions.assertNotEquals(null, taskLockPosse1);
+    Assertions.assertNotEquals(taskLockPosse1, taskLockPosse2);
+    Assertions.assertEquals(taskLockPosse1, taskLockPosse3);
   }
 
   @Test
@@ -1150,14 +1162,14 @@ public class GlobalTaskLockboxTest
     lockbox.add(task1);
     lockbox.add(task2);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task1,
             new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, task1, Intervals.of("2017/2018"), null)
         ).isOk()
     );
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task2,
             new SpecificSegmentLockRequest(TaskLockType.EXCLUSIVE, task2, Intervals.of("2017/2018"), "version", 0)
@@ -1169,20 +1181,20 @@ public class GlobalTaskLockboxTest
         .get(task1.getDataSource())
         .get(DateTimes.of("2017"))
         .get(Intervals.of("2017/2018"));
-    Assert.assertEquals(2, posses.size());
+    Assertions.assertEquals(2, posses.size());
 
-    Assert.assertEquals(LockGranularity.TIME_CHUNK, posses.get(0).getTaskLock().getGranularity());
+    Assertions.assertEquals(LockGranularity.TIME_CHUNK, posses.get(0).getTaskLock().getGranularity());
     final TimeChunkLock timeChunkLock = (TimeChunkLock) posses.get(0).getTaskLock();
-    Assert.assertEquals("none", timeChunkLock.getDataSource());
-    Assert.assertEquals("groupId", timeChunkLock.getGroupId());
-    Assert.assertEquals(Intervals.of("2017/2018"), timeChunkLock.getInterval());
+    Assertions.assertEquals("none", timeChunkLock.getDataSource());
+    Assertions.assertEquals("groupId", timeChunkLock.getGroupId());
+    Assertions.assertEquals(Intervals.of("2017/2018"), timeChunkLock.getInterval());
 
-    Assert.assertEquals(LockGranularity.SEGMENT, posses.get(1).getTaskLock().getGranularity());
+    Assertions.assertEquals(LockGranularity.SEGMENT, posses.get(1).getTaskLock().getGranularity());
     final SegmentLock segmentLock = (SegmentLock) posses.get(1).getTaskLock();
-    Assert.assertEquals("none", segmentLock.getDataSource());
-    Assert.assertEquals("groupId", segmentLock.getGroupId());
-    Assert.assertEquals(Intervals.of("2017/2018"), segmentLock.getInterval());
-    Assert.assertEquals(0, segmentLock.getPartitionId());
+    Assertions.assertEquals("none", segmentLock.getDataSource());
+    Assertions.assertEquals("groupId", segmentLock.getGroupId());
+    Assertions.assertEquals(Intervals.of("2017/2018"), segmentLock.getInterval());
+    Assertions.assertEquals(0, segmentLock.getPartitionId());
   }
 
   @Test
@@ -1194,14 +1206,14 @@ public class GlobalTaskLockboxTest
     lockbox.add(task1);
     lockbox.add(task2);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         lockbox.tryLock(
             task1,
             new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, task1, Intervals.of("2017/2018"), null)
         ).isOk()
     );
 
-    Assert.assertFalse(
+    Assertions.assertFalse(
         lockbox.tryLock(
             task2,
             new SpecificSegmentLockRequest(TaskLockType.EXCLUSIVE, task2, Intervals.of("2017/2018"), "version", 0)
@@ -1230,7 +1242,7 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<Interval>> conflictingIntervals =
         lockbox.getLockedIntervals(ImmutableList.of(requestForExclusiveLowerPriorityLock));
-    Assert.assertTrue(conflictingIntervals.isEmpty());
+    Assertions.assertTrue(conflictingIntervals.isEmpty());
   }
 
   @Test
@@ -1254,8 +1266,8 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<Interval>> conflictingIntervals =
         lockbox.getLockedIntervals(ImmutableList.of(requestForExclusiveLowerPriorityLock));
-    Assert.assertEquals(1, conflictingIntervals.size());
-    Assert.assertEquals(
+    Assertions.assertEquals(1, conflictingIntervals.size());
+    Assertions.assertEquals(
         Collections.singletonList(Intervals.of("2017/2018")),
         conflictingIntervals.get(task.getDataSource())
     );
@@ -1282,7 +1294,7 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<Interval>> conflictingIntervals =
         lockbox.getLockedIntervals(ImmutableList.of(requestForReplaceLowerPriorityLock));
-    Assert.assertTrue(conflictingIntervals.isEmpty());
+    Assertions.assertTrue(conflictingIntervals.isEmpty());
   }
 
   @Test
@@ -1311,7 +1323,7 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<Interval>> conflictingIntervals =
         lockbox.getLockedIntervals(ImmutableList.of(requestForReplaceLowerPriorityLock));
-    Assert.assertTrue(conflictingIntervals.isEmpty());
+    Assertions.assertTrue(conflictingIntervals.isEmpty());
   }
 
   @Test
@@ -1336,7 +1348,7 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<Interval>> conflictingIntervals =
         lockbox.getLockedIntervals(ImmutableList.of(requestForExclusiveLowerPriorityLock));
-    Assert.assertTrue(conflictingIntervals.isEmpty());
+    Assertions.assertTrue(conflictingIntervals.isEmpty());
   }
 
 
@@ -1378,8 +1390,8 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<TaskLock>> activeLocks =
         lockbox.getActiveLocks(ImmutableList.of(policy, policyForNonExistentDatasource));
-    Assert.assertEquals(1, activeLocks.size());
-    Assert.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
+    Assertions.assertEquals(1, activeLocks.size());
+    Assertions.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
   }
 
   @Test
@@ -1418,8 +1430,8 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<TaskLock>> activeLocks =
         lockbox.getActiveLocks(ImmutableList.of(policy, policyForNonExistentDatasource));
-    Assert.assertEquals(1, activeLocks.size());
-    Assert.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
+    Assertions.assertEquals(1, activeLocks.size());
+    Assertions.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
   }
 
   @Test
@@ -1458,8 +1470,8 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<TaskLock>> activeLocks =
         lockbox.getActiveLocks(ImmutableList.of(policy, policyForNonExistentDatasource));
-    Assert.assertEquals(1, activeLocks.size());
-    Assert.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
+    Assertions.assertEquals(1, activeLocks.size());
+    Assertions.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
   }
 
   @Test
@@ -1501,8 +1513,8 @@ public class GlobalTaskLockboxTest
 
     Map<String, List<TaskLock>> activeLocks =
         lockbox.getActiveLocks(ImmutableList.of(policy, policyForNonExistentDatasource));
-    Assert.assertEquals(1, activeLocks.size());
-    Assert.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
+    Assertions.assertEquals(1, activeLocks.size());
+    Assertions.assertEquals(expectedLocks, new HashSet<>(activeLocks.get("none")));
   }
 
   @Test
@@ -1951,7 +1963,7 @@ public class GlobalTaskLockboxTest
     lockbox.add(nonKillTask);
     taskStorage.insert(nonKillTask, TaskStatus.running(nonKillTask.getId()));
 
-    Assert.assertThrows(
+    Assertions.assertThrows(
         ISE.class,
         () -> lockbox.tryLock(
             nonKillTask,
@@ -1990,12 +2002,12 @@ public class GlobalTaskLockboxTest
     // Sync from storage — the kill task was not persisted, so the lock must disappear
     final GlobalTaskLockbox newBox = new GlobalTaskLockbox(taskStorage, metadataStorageCoordinator);
     final TaskLockboxSyncResult result = newBox.syncFromStorage();
-    Assert.assertEquals(0, result.getTaskLockCount());
+    Assertions.assertEquals(0, result.getTaskLockCount());
 
     // Verify that the lock is still present in storage
     final List<TaskLock> locksInStorage = taskStorage.getLocks(killTask.getId());
-    Assert.assertEquals(1, locksInStorage.size());
-    Assert.assertEquals(killLock, locksInStorage.getFirst());
+    Assertions.assertEquals(1, locksInStorage.size());
+    Assertions.assertEquals(killLock, locksInStorage.getFirst());
 
     // A new KILL lock on the same interval should now be grantable
     this.lockbox = newBox;
@@ -2013,8 +2025,8 @@ public class GlobalTaskLockboxTest
         lowPriorityKillTask,
         new TimeChunkLockRequest(TaskLockType.KILL, lowPriorityKillTask, Intervals.of("2017-06-01/2017-07-01"), null)
     );
-    Assert.assertTrue(lowResult.isOk());
-    Assert.assertFalse(lowResult.getTaskLock().isRevoked());
+    Assertions.assertTrue(lowResult.isOk());
+    Assertions.assertFalse(lowResult.getTaskLock().isRevoked());
 
     // High-priority kill task not in storage revokes the low-priority KILL lock
     final Task highPriorityKillTask = newEmbeddedKillTask(HIGH_PRIORITY);
@@ -2023,16 +2035,16 @@ public class GlobalTaskLockboxTest
         highPriorityKillTask,
         new TimeChunkLockRequest(TaskLockType.KILL, highPriorityKillTask, Intervals.of("2017/2018"), null)
     );
-    Assert.assertTrue(highResult.isOk());
-    Assert.assertFalse(highResult.getTaskLock().isRevoked());
+    Assertions.assertTrue(highResult.isOk());
+    Assertions.assertFalse(highResult.getTaskLock().isRevoked());
 
     // Re-acquiring the low-priority lock returns the revoked copy
     final LockResult revokedResult = lockbox.tryLock(
         lowPriorityKillTask,
         new TimeChunkLockRequest(TaskLockType.KILL, lowPriorityKillTask, Intervals.of("2017-06-01/2017-07-01"), null)
     );
-    Assert.assertFalse(revokedResult.isOk());
-    Assert.assertTrue(revokedResult.getTaskLock().isRevoked());
+    Assertions.assertFalse(revokedResult.isOk());
+    Assertions.assertTrue(revokedResult.getTaskLock().isRevoked());
 
     lockbox.remove(lowPriorityKillTask);
     lockbox.remove(highPriorityKillTask);
@@ -2049,7 +2061,7 @@ public class GlobalTaskLockboxTest
         exclusiveTask,
         new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, exclusiveTask, Intervals.of("2017-05-01/2017-06-01"), null)
     );
-    Assert.assertTrue(exclusiveResult.isOk());
+    Assertions.assertTrue(exclusiveResult.isOk());
 
     // A KILL task (not in storage) should be able to acquire a KILL lock on an overlapping interval
     final Task killTask = newEmbeddedKillTask(MEDIUM_PRIORITY);
@@ -2058,16 +2070,16 @@ public class GlobalTaskLockboxTest
         killTask,
         new TimeChunkLockRequest(TaskLockType.KILL, killTask, Intervals.of("2017/2018"), null)
     );
-    Assert.assertTrue(killResult.isOk());
-    Assert.assertFalse(killResult.getTaskLock().isRevoked());
+    Assertions.assertTrue(killResult.isOk());
+    Assertions.assertFalse(killResult.getTaskLock().isRevoked());
 
     // Release the kill task (not persisted)
     lockbox.remove(killTask);
 
     // The exclusive lock should still be active
     final List<TaskLock> exclusiveLocks = taskStorage.getLocks(exclusiveTask.getId());
-    Assert.assertEquals(1, exclusiveLocks.size());
-    Assert.assertFalse(exclusiveLocks.get(0).isRevoked());
+    Assertions.assertEquals(1, exclusiveLocks.size());
+    Assertions.assertFalse(exclusiveLocks.get(0).isRevoked());
 
     lockbox.remove(exclusiveTask);
   }
@@ -2110,7 +2122,7 @@ public class GlobalTaskLockboxTest
     taskStorage.insert(taskWithFailingLockAcquisition0, TaskStatus.running(taskWithFailingLockAcquisition0.getId()));
     taskStorage.insert(taskWithFailingLockAcquisition1, TaskStatus.running(taskWithFailingLockAcquisition1.getId()));
     taskStorage.insert(taskWithSuccessfulLockAcquisition, TaskStatus.running(taskWithSuccessfulLockAcquisition.getId()));
-    Assert.assertEquals(3, taskStorage.getActiveTasks().size());
+    Assertions.assertEquals(3, taskStorage.getActiveTasks().size());
 
     final TaskLock lock = new TimeChunkLock(
         null,
@@ -2128,7 +2140,7 @@ public class GlobalTaskLockboxTest
     TaskLockboxSyncResult result = testLockbox.syncFromStorage();
 
     // The tasks must be marked for failure
-    Assert.assertEquals(ImmutableSet.of(taskWithFailingLockAcquisition0, taskWithFailingLockAcquisition1),
+    Assertions.assertEquals(ImmutableSet.of(taskWithFailingLockAcquisition0, taskWithFailingLockAcquisition1),
                         result.getTasksToFail());
   }
 
@@ -2173,7 +2185,7 @@ public class GlobalTaskLockboxTest
         Intervals.of("2024-01-01/2024-01-02"),
         "v0"
     ).getTaskLock();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableSet.copyOf(taskStorage.getLocks(task.getId())),
         ImmutableSet.of(supersededLock)
     );
@@ -2185,7 +2197,7 @@ public class GlobalTaskLockboxTest
         Intervals.of("2024-01-01/2024-01-02"),
         "v0"
     ).getTaskLock();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableSet.copyOf(taskStorage.getLocks(otherTask.getId())),
         ImmutableSet.of(taskNotInPosse)
     );
@@ -2197,7 +2209,7 @@ public class GlobalTaskLockboxTest
         Intervals.of("2024-01-01/2025-01-01"),
         "v0"
     ).getTaskLock();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableSet.copyOf(taskStorage.getLocks(task.getId())),
         ImmutableSet.of(supersededLock, replaceLock)
     );
@@ -2209,7 +2221,7 @@ public class GlobalTaskLockboxTest
         Intervals.of("2024-01-11/2024-01-12"),
         "v1"
     ).getTaskLock();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableSet.copyOf(taskStorage.getLocks(task.getId())),
         ImmutableSet.of(supersededLock, replaceLock, higherVersion)
     );
@@ -2221,7 +2233,7 @@ public class GlobalTaskLockboxTest
         Intervals.of("2024-01-28/2024-02-04"),
         "v0"
     ).getTaskLock();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableSet.copyOf(taskStorage.getLocks(task.getId())),
         ImmutableSet.of(supersededLock, replaceLock, higherVersion, uncontainedInterval)
     );
@@ -2232,11 +2244,11 @@ public class GlobalTaskLockboxTest
         Intervals.of("2024-01-01/2024-02-01"),
         "v0"
     ).getTaskLock();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableSet.copyOf(taskStorage.getLocks(task.getId())),
         ImmutableSet.of(theLock, replaceLock, higherVersion, uncontainedInterval)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableSet.copyOf(taskStorage.getLocks(otherTask.getId())),
         ImmutableSet.of(taskNotInPosse)
     );
@@ -2283,14 +2295,13 @@ public class GlobalTaskLockboxTest
   public void test_add_throwsException_ifSyncIsNotComplete()
   {
     lockbox = new GlobalTaskLockbox(taskStorage, metadataStorageCoordinator);
-    MatcherAssert.assertThat(
-        Assert.assertThrows(
-            ISE.class,
-            () -> lockbox.add(NoopTask.create())
-        ),
-        ExceptionMatcher.of(ISE.class).expectMessageIs(
-            "Cannot get TaskLockbox for datasource[none] as sync with storage has not happened yet."
-        )
+    final ISE exception = Assertions.assertThrows(
+        ISE.class,
+        () -> lockbox.add(NoopTask.create())
+    );
+    Assertions.assertEquals(
+        "Cannot get TaskLockbox for datasource[none] as sync with storage has not happened yet.",
+        exception.getMessage()
     );
   }
 
@@ -2332,16 +2343,16 @@ public class GlobalTaskLockboxTest
     public TaskLock expectLockCreated(TaskLockType type, Task task, Interval interval)
     {
       final TaskLock lock = tryTaskLock(type, task, interval);
-      Assert.assertNotNull(lock);
-      Assert.assertFalse(lock.isRevoked());
+      Assertions.assertNotNull(lock);
+      Assertions.assertFalse(lock.isRevoked());
       return lock;
     }
 
     public TaskLock expectLockCreated(TaskLockType type, Interval interval, int priority)
     {
       final TaskLock lock = tryTaskLock(type, interval, priority);
-      Assert.assertNotNull(lock);
-      Assert.assertFalse(lock.isRevoked());
+      Assertions.assertNotNull(lock);
+      Assertions.assertFalse(lock.isRevoked());
       return lock;
     }
 
@@ -2353,23 +2364,23 @@ public class GlobalTaskLockboxTest
     public void expectLockNotGranted(TaskLockType type, Task task, Interval interval)
     {
       final TaskLock lock = tryTaskLock(type, task, interval);
-      Assert.assertNull(lock);
+      Assertions.assertNull(lock);
     }
 
     public void expectLockNotGranted(TaskLockType type, Interval interval, int priority)
     {
       final TaskLock lock = tryTaskLock(type, interval, priority);
-      Assert.assertNull(lock);
+      Assertions.assertNull(lock);
     }
 
     public void expectRevokedLocks(TaskLock... locks)
     {
       final Set<TaskLock> allLocks = getAllLocks();
       final Set<TaskLock> activeLocks = getAllActiveLocks();
-      Assert.assertEquals(locks.length, allLocks.size() - activeLocks.size());
+      Assertions.assertEquals(allLocks.size() - activeLocks.size(), locks.length);
       for (TaskLock lock : locks) {
-        Assert.assertTrue(allLocks.contains(lock.revokedCopy()));
-        Assert.assertFalse(activeLocks.contains(lock));
+        Assertions.assertTrue(allLocks.contains(lock.revokedCopy()));
+        Assertions.assertFalse(activeLocks.contains(lock));
       }
     }
 
@@ -2377,10 +2388,10 @@ public class GlobalTaskLockboxTest
     {
       final Set<TaskLock> allLocks = getAllLocks();
       final Set<TaskLock> activeLocks = getAllActiveLocks();
-      Assert.assertEquals(locks.length, activeLocks.size());
+      Assertions.assertEquals(activeLocks.size(), locks.length);
       for (TaskLock lock : locks) {
-        Assert.assertTrue(allLocks.contains(lock));
-        Assert.assertTrue(activeLocks.contains(lock));
+        Assertions.assertTrue(allLocks.contains(lock));
+        Assertions.assertTrue(activeLocks.contains(lock));
       }
     }
 
@@ -2411,15 +2422,15 @@ public class GlobalTaskLockboxTest
     public TaskLock expectKillLockCreated(Task killTask, Interval interval)
     {
       final TaskLock lock = tryTaskLock(TaskLockType.KILL, killTask, interval);
-      Assert.assertNotNull(lock);
-      Assert.assertFalse(lock.isRevoked());
+      Assertions.assertNotNull(lock);
+      Assertions.assertFalse(lock.isRevoked());
       return lock;
     }
 
     public void expectKillLockNotGranted(Task killTask, Interval interval)
     {
       final TaskLock lock = tryTaskLock(TaskLockType.KILL, killTask, interval);
-      Assert.assertNull(lock);
+      Assertions.assertNull(lock);
     }
 
     private Set<TaskLock> getAllActiveLocks()
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/HeapMemoryTaskStorageTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/HeapMemoryTaskStorageTest.java
index 7021d23fb50..c96176054f8 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/HeapMemoryTaskStorageTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/HeapMemoryTaskStorageTest.java
@@ -27,9 +27,9 @@ import org.apache.druid.indexing.common.task.NoopTask;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.metadata.TaskLookup;
 import org.joda.time.Period;
-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.List;
 
@@ -37,7 +37,7 @@ public class HeapMemoryTaskStorageTest
 {
   private HeapMemoryTaskStorage storage;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     storage = new HeapMemoryTaskStorage(new TaskStorageConfig(Period.days(1)));
@@ -52,12 +52,12 @@ public class HeapMemoryTaskStorageTest
     storage.insert(task2, TaskStatus.running(task2.getId()));
 
     storage.removeTasksOlderThan(DateTimes.of("2000").getMillis());
-    Assert.assertNotNull(storage.getTaskInfo(task1.getId()));
-    Assert.assertNotNull(storage.getTaskInfo(task2.getId()));
+    Assertions.assertNotNull(storage.getTaskInfo(task1.getId()));
+    Assertions.assertNotNull(storage.getTaskInfo(task2.getId()));
 
     storage.removeTasksOlderThan(DateTimes.of("3000").getMillis());
-    Assert.assertNull(storage.getTaskInfo(task1.getId()));
-    Assert.assertNotNull(storage.getTaskInfo(task2.getId()));
+    Assertions.assertNull(storage.getTaskInfo(task1.getId()));
+    Assertions.assertNotNull(storage.getTaskInfo(task2.getId()));
   }
 
   @Test
@@ -79,8 +79,8 @@ public class HeapMemoryTaskStorageTest
         null
     );
 
-    Assert.assertEquals(1, taskInfosActive.size());
-    Assert.assertEquals(task2.getId(), taskInfosActive.get(0).getTask().getId());
+    Assertions.assertEquals(1, taskInfosActive.size());
+    Assertions.assertEquals(task2.getId(), taskInfosActive.get(0).getTask().getId());
 
     // Complete statuses
     final List<TaskInfo> taskInfosComplete = storage.getTaskInfos(
@@ -91,7 +91,7 @@ public class HeapMemoryTaskStorageTest
         null
     );
 
-    Assert.assertEquals(1, taskInfosComplete.size());
-    Assert.assertEquals(task1.getId(), taskInfosComplete.get(0).getTask().getId());
+    Assertions.assertEquals(1, taskInfosComplete.size());
+    Assertions.assertEquals(task1.getId(), taskInfosComplete.get(0).getTask().getId());
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java
index 122e9892dc8..844fae30a48 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ImmutableWorkerInfoTest.java
@@ -30,8 +30,8 @@ import org.apache.druid.indexing.worker.Worker;
 import org.apache.druid.indexing.worker.config.WorkerConfig;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.common.DateTimes;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 
@@ -57,7 +57,7 @@ public class ImmutableWorkerInfoTest
         mapper.writeValueAsString(workerInfo),
         ImmutableWorkerInfo.class
     );
-    Assert.assertEquals(workerInfo, serde);
+    Assertions.assertEquals(workerInfo, serde);
   }
 
   @Test
@@ -244,10 +244,10 @@ public class ImmutableWorkerInfoTest
     when(parallelIndexTask.getTaskResource()).thenReturn(taskResource0);
 
     // Since task satisifies parallel and total slot constraints, can run
-    Assert.assertTrue(workerInfo.canRunTask(parallelIndexTask, 0.5));
+    Assertions.assertTrue(workerInfo.canRunTask(parallelIndexTask, 0.5));
 
     // Since task fails the parallel slot constraint, it cannot run (3 > 1)
-    Assert.assertFalse(workerInfo.canRunTask(parallelIndexTask, 0.1));
+    Assertions.assertFalse(workerInfo.canRunTask(parallelIndexTask, 0.1));
 
 
     // Some other indexing task
@@ -259,7 +259,7 @@ public class ImmutableWorkerInfoTest
 
     // Not a parallel index task ->  satisfies parallel index constraint
     // But does not satisfy the total slot constraint and cannot run (11 > 10)
-    Assert.assertFalse(workerInfo.canRunTask(anyOtherTask, 0.5));
+    Assertions.assertFalse(workerInfo.canRunTask(anyOtherTask, 0.5));
 
 
     // Task has an availability conflict ("grp1")
@@ -271,17 +271,17 @@ public class ImmutableWorkerInfoTest
     when(grp1Task.getTaskResource()).thenReturn(taskResource2);
 
     // Satisifies parallel index and total index slot constraints but cannot run due availability
-    Assert.assertFalse(workerInfo.canRunTask(grp1Task, 0.3));
+    Assertions.assertFalse(workerInfo.canRunTask(grp1Task, 0.3));
   }
 
   private void assertEqualsAndHashCode(ImmutableWorkerInfo o1, ImmutableWorkerInfo o2, boolean shouldMatch)
   {
     if (shouldMatch) {
-      Assert.assertTrue(o1.equals(o2));
-      Assert.assertEquals(o1.hashCode(), o2.hashCode());
+      Assertions.assertTrue(o1.equals(o2));
+      Assertions.assertEquals(o1.hashCode(), o2.hashCode());
     } else {
-      Assert.assertFalse(o1.equals(o2));
-      Assert.assertNotEquals(o1.hashCode(), o2.hashCode());
+      Assertions.assertFalse(o1.equals(o2));
+      Assertions.assertNotEquals(o1.hashCode(), o2.hashCode());
     }
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageAdapterTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageAdapterTest.java
index 870f99a309f..66f7b5dd46e 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageAdapterTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/IndexerMetadataStorageAdapterTest.java
@@ -21,7 +21,6 @@ package org.apache.druid.indexing.overlord;
 
 import com.google.common.collect.ImmutableList;
 import org.apache.druid.error.DruidException;
-import org.apache.druid.error.DruidExceptionMatcher;
 import org.apache.druid.indexer.TaskInfo;
 import org.apache.druid.indexer.TaskStatus;
 import org.apache.druid.indexing.common.task.NoopTask;
@@ -29,11 +28,10 @@ import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.metadata.TaskLookup;
 import org.easymock.EasyMock;
-import org.hamcrest.MatcherAssert;
 import org.joda.time.Interval;
-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.List;
 
@@ -43,7 +41,7 @@ public class IndexerMetadataStorageAdapterTest
   private IndexerMetadataStorageCoordinator indexerMetadataStorageCoordinator;
   private IndexerMetadataStorageAdapter indexerMetadataStorageAdapter;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     indexerMetadataStorageCoordinator = EasyMock.strictMock(IndexerMetadataStorageCoordinator.class);
@@ -82,7 +80,7 @@ public class IndexerMetadataStorageAdapterTest
         .andReturn(10);
     EasyMock.replay(taskStorage, indexerMetadataStorageCoordinator);
 
-    Assert.assertEquals(10, indexerMetadataStorageAdapter.deletePendingSegments("dataSource", deleteInterval));
+    Assertions.assertEquals(10, indexerMetadataStorageAdapter.deletePendingSegments("dataSource", deleteInterval));
   }
 
   @Test
@@ -115,16 +113,18 @@ public class IndexerMetadataStorageAdapterTest
         .andReturn(10);
     EasyMock.replay(taskStorage, indexerMetadataStorageCoordinator);
 
-    MatcherAssert.assertThat(
-        Assert.assertThrows(
-            DruidException.class,
-            () -> indexerMetadataStorageAdapter.deletePendingSegments("dataSource", deleteInterval)
-        ),
-        DruidExceptionMatcher.invalidInput().expectMessageIs(
-            "Cannot delete pendingSegments for datasource[dataSource] as there is at least one active task[id1]"
-            + " created at[2017-11-01T00:00:00.000Z] that overlaps with the delete "
-            + "interval[2017-01-01T00:00:00.000Z/2017-12-01T00:00:00.000Z]. Please retry when there are no active tasks."
-        )
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> indexerMetadataStorageAdapter.deletePendingSegments("dataSource", deleteInterval)
+    );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.INVALID_INPUT, exception.getCategory());
+    Assertions.assertEquals("invalidInput", exception.getErrorCode());
+    Assertions.assertEquals(
+        "Cannot delete pendingSegments for datasource[dataSource] as there is at least one active task[id1]"
+        + " created at[2017-11-01T00:00:00.000Z] that overlaps with the delete "
+        + "interval[2017-01-01T00:00:00.000Z/2017-12-01T00:00:00.000Z]. Please retry when there are no active tasks.",
+        exception.getMessage()
     );
   }
 
@@ -158,16 +158,18 @@ public class IndexerMetadataStorageAdapterTest
         .andReturn(10);
     EasyMock.replay(taskStorage, indexerMetadataStorageCoordinator);
 
-    MatcherAssert.assertThat(
-        Assert.assertThrows(
-            DruidException.class,
-            () -> indexerMetadataStorageAdapter.deletePendingSegments("dataSource", deleteInterval)
-        ),
-        DruidExceptionMatcher.invalidInput().expectMessageIs(
-            "Cannot delete pendingSegments for datasource[dataSource] as there is at least one active task[id2]"
-            + " created at[2017-11-01T00:00:00.000Z] that overlaps with the delete"
-            + " interval[2017-01-01T00:00:00.000Z/2018-12-01T00:00:00.000Z]. Please retry when there are no active tasks."
-        )
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> indexerMetadataStorageAdapter.deletePendingSegments("dataSource", deleteInterval)
+    );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.INVALID_INPUT, exception.getCategory());
+    Assertions.assertEquals("invalidInput", exception.getErrorCode());
+    Assertions.assertEquals(
+        "Cannot delete pendingSegments for datasource[dataSource] as there is at least one active task[id2]"
+        + " created at[2017-11-01T00:00:00.000Z] that overlaps with the delete"
+        + " interval[2017-01-01T00:00:00.000Z/2018-12-01T00:00:00.000Z]. Please retry when there are no active tasks.",
+        exception.getMessage()
     );
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/PortFinderTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/PortFinderTest.java
index f57093cc806..337eba62cab 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/PortFinderTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/PortFinderTest.java
@@ -21,9 +21,9 @@ package org.apache.druid.indexing.overlord;
 
 import com.google.common.collect.ImmutableList;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -33,7 +33,7 @@ public class PortFinderTest
 {
   private final List<PortFinder> finders = new ArrayList<>();
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     // use startPort and endPort to generate usable ports.
@@ -60,11 +60,11 @@ public class PortFinderTest
       EasyMock.replay(finder);
 
       final int port1 = finder.findUnusedPort();
-      Assert.assertEquals(1200, port1);
+      Assertions.assertEquals(1200, port1);
       finder.markPortUnused(port1);
 
       final int port2 = finder.findUnusedPort();
-      Assert.assertEquals(1201, port2);
+      Assertions.assertEquals(1201, port2);
       finder.markPortUnused(port2);
 
       EasyMock.verify(finder);
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RealtimeishTask.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RealtimeishTask.java
index d2103f23cac..29a1df2b814 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RealtimeishTask.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/RealtimeishTask.java
@@ -35,7 +35,7 @@ import org.apache.druid.indexing.common.task.TaskResource;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Interval;
-import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
 
 import java.util.Collections;
 import java.util.List;
@@ -78,23 +78,23 @@ public class RealtimeishTask extends AbstractTask
     final TaskLock lock1 = toolbox.getTaskActionClient().submit(
         new TimeChunkLockAcquireAction(TaskLockType.EXCLUSIVE, interval1, 5000)
     );
-    Assert.assertNotNull(lock1);
+    Assertions.assertNotNull(lock1);
     final List<TaskLock> locks1 = toolbox.getTaskActionClient().submit(new LockListAction());
 
     // (Confirm lock sanity)
-    Assert.assertEquals("lock1 interval", interval1, lock1.getInterval());
-    Assert.assertEquals("locks1", ImmutableList.of(lock1), locks1);
+    Assertions.assertEquals(interval1, lock1.getInterval(), "lock1 interval");
+    Assertions.assertEquals(ImmutableList.of(lock1), locks1, "locks1");
 
     // Acquire lock for second interval
     final TaskLock lock2 = toolbox.getTaskActionClient().submit(
         new TimeChunkLockAcquireAction(TaskLockType.EXCLUSIVE, interval2, 5000)
     );
-    Assert.assertNotNull(lock2);
+    Assertions.assertNotNull(lock2);
     final List<TaskLock> locks2 = toolbox.getTaskActionClient().submit(new LockListAction());
 
     // (Confirm lock sanity)
-    Assert.assertEquals("lock2 interval", interval2, lock2.getInterval());
-    Assert.assertEquals("locks2", ImmutableList.of(lock1, lock2), locks2);
+    Assertions.assertEquals(interval2, lock2.getInterval(), "lock2 interval");
+    Assertions.assertEquals(ImmutableList.of(lock1, lock2), locks2, "locks2");
 
     // Push first segment
     toolbox.getTaskActionClient().submit(createSegmentInsertAction(interval1, lock1.getVersion()));
@@ -104,7 +104,7 @@ public class RealtimeishTask extends AbstractTask
     final List<TaskLock> locks3 = toolbox.getTaskActionClient().submit(new LockListAction());
 
     // (Confirm lock sanity)
-    Assert.assertEquals("locks3", ImmutableList.of(lock2), locks3);
+    Assertions.assertEquals(ImmutableList.of(lock2), locks3, "locks3");
 
     // Push second segment
     toolbox.getTaskActionClient().submit(createSegmentInsertAction(interval2, lock2.getVersion()));
@@ -114,7 +114,7 @@ public class RealtimeishTask extends AbstractTask
     final List<TaskLock> locks4 = toolbox.getTaskActionClient().submit(new LockListAction());
 
     // (Confirm lock sanity)
-    Assert.assertEquals("locks4", ImmutableList.<TaskLock>of(), locks4);
+    Assertions.assertEquals(ImmutableList.<TaskLock>of(), locks4, "locks4");
 
     // Exit
     return TaskStatus.success(getId());
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java
index 78519fe3302..81d75b923f7 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/SingleTaskBackgroundRunnerTest.java
@@ -63,14 +63,11 @@ import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.apache.druid.server.security.AuthTestUtils;
 import org.apache.druid.utils.JvmUtils;
 import org.easymock.EasyMock;
-import org.hamcrest.CoreMatchers;
-import org.hamcrest.MatcherAssert;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 
 import javax.annotation.Nullable;
 import java.io.File;
@@ -84,18 +81,18 @@ import java.util.concurrent.atomic.AtomicReference;
 
 public class SingleTaskBackgroundRunnerTest
 {
-  @Rule
-  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @TempDir
+  private File temporaryFolder;
 
   private SingleTaskBackgroundRunner runner;
 
-  @Before
+  @BeforeEach
   public void setup() throws IOException
   {
     final TestUtils utils = new TestUtils();
     final DruidNode node = new DruidNode("testServer", "testHost", false, 1000, null, true, false);
     final TaskConfig taskConfig = new TaskConfigBuilder()
-        .setBaseDir(temporaryFolder.newFile().toString())
+        .setBaseDir(File.createTempFile("base", null, temporaryFolder).toString())
         .setRestoreTasksOnRestart(true)
         .build();
     final ServiceEmitter emitter = new NoopServiceEmitter();
@@ -154,7 +151,7 @@ public class SingleTaskBackgroundRunnerTest
     );
   }
 
-  @After
+  @AfterEach
   public void teardown()
   {
     runner.stop();
@@ -164,7 +161,7 @@ public class SingleTaskBackgroundRunnerTest
   public void testRun() throws ExecutionException, InterruptedException
   {
     NoopTask task = new NoopTask(null, null, null, 500L, 0, null);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         TaskState.SUCCESS,
         runner.run(task).get().getStatusCode()
     );
@@ -182,7 +179,7 @@ public class SingleTaskBackgroundRunnerTest
             .build()
             .getRunner(runner);
 
-    MatcherAssert.assertThat(queryRunner, CoreMatchers.instanceOf(SetAndVerifyContextQueryRunner.class));
+    Assertions.assertInstanceOf(SetAndVerifyContextQueryRunner.class, queryRunner);
   }
 
   @Test
@@ -201,11 +198,11 @@ public class SingleTaskBackgroundRunnerTest
         }
     );
     runner.stop();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         TaskState.FAILED,
         future.get(1000, TimeUnit.MILLISECONDS).getStatusCode()
     );
-    Assert.assertTrue(methodCallHolder.get());
+    Assertions.assertTrue(methodCallHolder.get());
   }
 
   @Test
@@ -216,11 +213,11 @@ public class SingleTaskBackgroundRunnerTest
         new RestorableTask(holder)
     );
     runner.stop();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         TaskState.SUCCESS,
         future.get(1000, TimeUnit.MILLISECONDS).getStatusCode()
     );
-    Assert.assertTrue(holder.get());
+    Assertions.assertTrue(holder.get());
   }
 
   @Test
@@ -275,8 +272,8 @@ public class SingleTaskBackgroundRunnerTest
         }
     );
     runner.stop();
-    Assert.assertEquals(TaskState.FAILED, statusHolder.get().getStatusCode());
-    Assert.assertEquals(
+    Assertions.assertEquals(TaskState.FAILED, statusHolder.get().getStatusCode());
+    Assertions.assertEquals(
         "Failed to stop gracefully with exception. See task logs for more details.",
         statusHolder.get().getErrorMsg()
     );
@@ -336,10 +333,10 @@ public class SingleTaskBackgroundRunnerTest
         }
     );
 
-    Assert.assertTrue(runLatch.await(1, TimeUnit.SECONDS));
+    Assertions.assertTrue(runLatch.await(1, TimeUnit.SECONDS));
     runner.stop();
 
-    Assert.assertEquals(TaskState.FAILED, statusHolder.get().getStatusCode());
+    Assertions.assertEquals(TaskState.FAILED, statusHolder.get().getStatusCode());
 
     // Do not verify the failure error message as there is a race condition
     // where the error message may either originate from NoopTask or the runner
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
index 16149e88a63..55828b9f0c0 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLifecycleTest.java
@@ -145,14 +145,13 @@ import org.joda.time.DateTime;
 import org.joda.time.Hours;
 import org.joda.time.Interval;
 import org.joda.time.Period;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import javax.annotation.Nullable;
 import java.io.File;
@@ -171,7 +170,8 @@ import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass(name = "taskStorageType={0}")
+@MethodSource("constructFeed")
 public class TaskLifecycleTest extends InitializedNullHandlingTest
 {
   private static final ObjectMapper MAPPER;
@@ -191,7 +191,6 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
   private static final String HEAP_TASK_STORAGE = "HeapMemoryTaskStorage";
   private static final String METADATA_TASK_STORAGE = "MetadataTaskStorage";
 
-  @Parameterized.Parameters(name = "taskStorageType={0}")
   public static Collection<String[]> constructFeed()
   {
     return Arrays.asList(new String[][]{{HEAP_TASK_STORAGE}, {METADATA_TASK_STORAGE}});
@@ -202,8 +201,8 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     this.taskStorageType = taskStorageType;
   }
 
-  @Rule
-  public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+  @TempDir
+  private File temporaryFolder;
 
   private static final Ordering<DataSegment> BY_INTERVAL_ORDERING = new Ordering<>()
   {
@@ -228,8 +227,12 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
       ir("2010-01-02T01", "a", "c", 1)
   );
 
-  @Rule
-  public final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule = new TestDerbyConnector.DerbyConnectorRule();
+  private final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule = new TestDerbyConnector.DerbyConnectorRule();
+
+  private File newTempFolder()
+  {
+    return FileUtils.createTempDirInLocation(temporaryFolder.toPath(), "tmp");
+  }
 
   private final String taskStorageType;
 
@@ -368,9 +371,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     }
   }
 
-  @Before
+  @BeforeEach
   public void setUp() throws Exception
   {
+    derbyConnectorRule.before();
     // mock things
     queryRunnerFactoryConglomerate = EasyMock.createStrictMock(QueryRunnerFactoryConglomerate.class);
     monitorScheduler = EasyMock.createStrictMock(MonitorScheduler.class);
@@ -522,7 +526,7 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
       DataSegmentPusher dataSegmentPusher,
       SegmentHandoffNotifierFactory handoffNotifierFactory,
       TestIndexerMetadataStorageCoordinator mdc
-  ) throws IOException
+  )
   {
     return setUpTaskToolboxFactory(dataSegmentPusher, handoffNotifierFactory, mdc, new TestAppenderatorsManager());
   }
@@ -532,7 +536,7 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
       SegmentHandoffNotifierFactory handoffNotifierFactory,
       TestIndexerMetadataStorageCoordinator mdc,
       AppenderatorsManager appenderatorsManager
-  ) throws IOException
+  )
   {
     Preconditions.checkNotNull(queryRunnerFactoryConglomerate);
     Preconditions.checkNotNull(monitorScheduler);
@@ -551,7 +555,7 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
         )
     );
     taskConfig = new TaskConfigBuilder()
-        .setBaseDir(temporaryFolder.newFolder().toString())
+        .setBaseDir(newTempFolder().toString())
         .setTmpStorageBytesPerTask(-1L)
         .build();
 
@@ -650,12 +654,13 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     );
   }
 
-  @After
-  public void tearDown()
+  @AfterEach
+  public void tearDown() throws IOException
   {
     if (taskQueue.isActive()) {
       taskQueue.stop();
     }
+    derbyConnectorRule.after();
   }
 
   @Test
@@ -691,35 +696,35 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     );
 
     final Optional<TaskStatus> preRunTaskStatus = tsqa.getTaskStatus(indexTask.getId());
-    Assert.assertTrue("pre run task status not present", !preRunTaskStatus.isPresent());
+    Assertions.assertTrue(!preRunTaskStatus.isPresent(), "pre run task status not present");
 
     final TaskStatus mergedStatus = runTask(indexTask);
     final TaskStatus status = taskStorage.getStatus(indexTask.getId()).get();
     final List<DataSegment> publishedSegments = BY_INTERVAL_ORDERING.sortedCopy(mdc.getPublished());
 
-    Assert.assertEquals("statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("merged statusCode", TaskState.SUCCESS, mergedStatus.getStatusCode());
-    Assert.assertEquals("num segments published", 2, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(TaskState.SUCCESS, mergedStatus.getStatusCode(), "merged statusCode");
+    Assertions.assertEquals(2, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "num segments nuked");
 
-    Assert.assertEquals("segment1 datasource", "foo", publishedSegments.get(0).getDataSource());
-    Assert.assertEquals("segment1 interval", Intervals.of("2010-01-01/P1D"), publishedSegments.get(0).getInterval());
-    Assert.assertEquals(
-        "segment1 dimensions",
+    Assertions.assertEquals("foo", publishedSegments.get(0).getDataSource(), "segment1 datasource");
+    Assertions.assertEquals(Intervals.of("2010-01-01/P1D"), publishedSegments.get(0).getInterval(), "segment1 interval");
+    Assertions.assertEquals(
         ImmutableList.of("dim1", "dim2"),
-        publishedSegments.get(0).getDimensions()
+        publishedSegments.get(0).getDimensions(),
+        "segment1 dimensions"
     );
-    Assert.assertEquals("segment1 metrics", ImmutableList.of("met"), publishedSegments.get(0).getMetrics());
+    Assertions.assertEquals(ImmutableList.of("met"), publishedSegments.get(0).getMetrics(), "segment1 metrics");
 
-    Assert.assertEquals("segment2 datasource", "foo", publishedSegments.get(1).getDataSource());
-    Assert.assertEquals("segment2 interval", Intervals.of("2010-01-02/P1D"), publishedSegments.get(1).getInterval());
-    Assert.assertEquals(
-        "segment2 dimensions",
+    Assertions.assertEquals("foo", publishedSegments.get(1).getDataSource(), "segment2 datasource");
+    Assertions.assertEquals(Intervals.of("2010-01-02/P1D"), publishedSegments.get(1).getInterval(), "segment2 interval");
+    Assertions.assertEquals(
         ImmutableList.of("dim1", "dim2"),
-        publishedSegments.get(1).getDimensions()
+        publishedSegments.get(1).getDimensions(),
+        "segment2 dimensions"
     );
-    Assert.assertEquals("segment2 metrics", ImmutableList.of("met"), publishedSegments.get(1).getMetrics());
+    Assertions.assertEquals(ImmutableList.of("met"), publishedSegments.get(1).getMetrics(), "segment2 metrics");
   }
 
   @Test
@@ -755,16 +760,16 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
 
     final TaskStatus status = runTask(indexTask);
 
-    Assert.assertEquals("statusCode", TaskState.FAILED, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("num segments published", 0, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.FAILED, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(0, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "num segments nuked");
   }
 
   @Test
   public void testKillUnusedSegmentsTask() throws Exception
   {
-    final File tmpSegmentDir = temporaryFolder.newFolder();
+    final File tmpSegmentDir = newTempFolder();
 
     List<DataSegment> expectedUnusedSegments = Lists.transform(
         ImmutableList.of(
@@ -842,27 +847,27 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
         );
 
     final TaskStatus status = runTask(killUnusedSegmentsTask);
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("merged statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals("num segments published", 3, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", 3, mdc.getNuked().size());
-    Assert.assertEquals("delete segment batch call count", 1, mdc.getDeleteSegmentsCount());
-    Assert.assertTrue(
-        "expected unused segments get killed",
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "merged statusCode");
+    Assertions.assertEquals(3, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(3, mdc.getNuked().size(), "num segments nuked");
+    Assertions.assertEquals(1, mdc.getDeleteSegmentsCount(), "delete segment batch call count");
+    Assertions.assertTrue(
         expectedUnusedSegments.containsAll(mdc.getNuked()) && mdc.getNuked().containsAll(
             expectedUnusedSegments
-        )
+        ),
+        "expected unused segments get killed"
     );
 
     for (File file : segmentFiles) {
-      Assert.assertFalse("unused segments files get deleted", file.exists());
+      Assertions.assertFalse(file.exists(), "unused segments files get deleted");
     }
   }
 
   @Test
   public void testKillUnusedSegmentsTaskWithMaxSegmentsToKill() throws Exception
   {
-    final File tmpSegmentDir = temporaryFolder.newFolder();
+    final File tmpSegmentDir = newTempFolder();
 
     List<DataSegment> expectedUnusedSegments = Lists.transform(
         ImmutableList.of(
@@ -941,13 +946,13 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
         );
 
     final TaskStatus status = runTask(killUnusedSegmentsTask);
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("merged statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals("num segments published", 3, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", maxSegmentsToKill, mdc.getNuked().size());
-    Assert.assertTrue(
-        "expected unused segments get killed",
-        expectedUnusedSegments.containsAll(mdc.getNuked())
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "merged statusCode");
+    Assertions.assertEquals(3, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(maxSegmentsToKill, mdc.getNuked().size(), "num segments nuked");
+    Assertions.assertTrue(
+        expectedUnusedSegments.containsAll(mdc.getNuked()),
+        "expected unused segments get killed"
     );
 
     int expectedNumOfSegmentsRemaining = segmentFiles.size() - maxSegmentsToKill;
@@ -958,10 +963,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
       }
     }
 
-    Assert.assertEquals(
-        "Expected of segments deleted did not match expectations",
+    Assertions.assertEquals(
         expectedNumOfSegmentsRemaining,
-        actualNumOfSegmentsRemaining
+        actualNumOfSegmentsRemaining,
+        "Expected of segments deleted did not match expectations"
     );
   }
 
@@ -971,10 +976,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     final Task rtishTask = new RealtimeishTask();
     final TaskStatus status = runTask(rtishTask);
 
-    Assert.assertEquals("statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("num segments published", 2, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(2, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "num segments nuked");
   }
 
   @Test
@@ -982,10 +987,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
   {
     final TaskStatus status = runTask(NoopTask.create());
 
-    Assert.assertEquals("statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("num segments published", 0, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(0, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "num segments nuked");
   }
 
   @Test
@@ -1001,10 +1006,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     };
     final TaskStatus status = runTask(neverReadyTask);
 
-    Assert.assertEquals("statusCode", TaskState.FAILED, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("num segments published", 0, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.FAILED, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(0, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "num segments nuked");
   }
 
   @Test
@@ -1060,10 +1065,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     };
 
     final TaskStatus status = runTask(task);
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals("segments published", 1, mdc.getPublished().size());
-    Assert.assertEquals("segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(1, mdc.getPublished().size(), "segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "segments nuked");
   }
 
   @Test
@@ -1104,10 +1109,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
 
     final TaskStatus status = runTask(task);
 
-    Assert.assertEquals("statusCode", TaskState.FAILED, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("segments published", 0, mdc.getPublished().size());
-    Assert.assertEquals("segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.FAILED, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(0, mdc.getPublished().size(), "segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "segments nuked");
   }
 
   @Test
@@ -1148,10 +1153,10 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
 
     final TaskStatus status = runTask(task);
 
-    Assert.assertEquals("statusCode", TaskState.FAILED, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("segments published", 0, mdc.getPublished().size());
-    Assert.assertEquals("segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.FAILED, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(0, mdc.getPublished().size(), "segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "segments nuked");
   }
 
   @Test
@@ -1201,28 +1206,28 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     final TaskStatus status = taskStorage.getStatus(indexTask.getId()).get();
     final List<DataSegment> publishedSegments = BY_INTERVAL_ORDERING.sortedCopy(mdc.getPublished());
 
-    Assert.assertEquals("statusCode", TaskState.SUCCESS, status.getStatusCode());
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("num segments published", 2, mdc.getPublished().size());
-    Assert.assertEquals("num segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(2, mdc.getPublished().size(), "num segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "num segments nuked");
 
-    Assert.assertEquals("segment1 datasource", "foo", publishedSegments.get(0).getDataSource());
-    Assert.assertEquals("segment1 interval", Intervals.of("2010-01-01/P1D"), publishedSegments.get(0).getInterval());
-    Assert.assertEquals(
-        "segment1 dimensions",
+    Assertions.assertEquals("foo", publishedSegments.get(0).getDataSource(), "segment1 datasource");
+    Assertions.assertEquals(Intervals.of("2010-01-01/P1D"), publishedSegments.get(0).getInterval(), "segment1 interval");
+    Assertions.assertEquals(
         ImmutableList.of("dim1", "dim2"),
-        publishedSegments.get(0).getDimensions()
+        publishedSegments.get(0).getDimensions(),
+        "segment1 dimensions"
     );
-    Assert.assertEquals("segment1 metrics", ImmutableList.of("met"), publishedSegments.get(0).getMetrics());
+    Assertions.assertEquals(ImmutableList.of("met"), publishedSegments.get(0).getMetrics(), "segment1 metrics");
 
-    Assert.assertEquals("segment2 datasource", "foo", publishedSegments.get(1).getDataSource());
-    Assert.assertEquals("segment2 interval", Intervals.of("2010-01-02/P1D"), publishedSegments.get(1).getInterval());
-    Assert.assertEquals(
-        "segment2 dimensions",
+    Assertions.assertEquals("foo", publishedSegments.get(1).getDataSource(), "segment2 datasource");
+    Assertions.assertEquals(Intervals.of("2010-01-02/P1D"), publishedSegments.get(1).getInterval(), "segment2 interval");
+    Assertions.assertEquals(
         ImmutableList.of("dim1", "dim2"),
-        publishedSegments.get(1).getDimensions()
+        publishedSegments.get(1).getDimensions(),
+        "segment2 dimensions"
     );
-    Assert.assertEquals("segment2 metrics", ImmutableList.of("met"), publishedSegments.get(1).getMetrics());
+    Assertions.assertEquals(ImmutableList.of("met"), publishedSegments.get(1).getMetrics(), "segment2 metrics");
   }
 
   @Test
@@ -1276,21 +1281,21 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
     );
 
     final Optional<TaskStatus> preRunTaskStatus = tsqa.getTaskStatus(indexTask.getId());
-    Assert.assertTrue("pre run task status not present", !preRunTaskStatus.isPresent());
+    Assertions.assertTrue(!preRunTaskStatus.isPresent(), "pre run task status not present");
 
     final TaskStatus mergedStatus = runTask(indexTask);
     final TaskStatus status = taskStorage.getStatus(indexTask.getId()).get();
 
-    Assert.assertEquals("statusCode", TaskState.SUCCESS, status.getStatusCode());
+    Assertions.assertEquals(TaskState.SUCCESS, status.getStatusCode(), "statusCode");
 
     Map<String, UnifiedIndexerAppenderatorsManager.DatasourceBundle> bundleMap =
         unifiedIndexerAppenderatorsManager.getDatasourceBundles();
 
-    Assert.assertEquals(1, bundleMap.size());
+    Assertions.assertEquals(1, bundleMap.size());
 
     unifiedIndexerAppenderatorsManager.removeAppenderatorsForTask(indexTask.getId(), "foo");
 
-    Assert.assertTrue(bundleMap.isEmpty());
+    Assertions.assertTrue(bundleMap.isEmpty());
 
   }
 
@@ -1332,21 +1337,21 @@ public class TaskLifecycleTest extends InitializedNullHandlingTest
         }
 
         final TaskLock lockBeforeRevoke = toolbox.getTaskActionClient().submit(action);
-        Assert.assertFalse(lockBeforeRevoke.isRevoked());
+        Assertions.assertFalse(lockBeforeRevoke.isRevoked());
 
         taskLockbox.revokeLock(getId(), lock);
 
         final TaskLock lockAfterRevoke = toolbox.getTaskActionClient().submit(action);
-        Assert.assertTrue(lockAfterRevoke.isRevoked());
+        Assertions.assertTrue(lockAfterRevoke.isRevoked());
         return TaskStatus.failure(getId(), "lock revoked test");
       }
     };
 
     final TaskStatus status = runTask(task);
-    Assert.assertEquals(taskLocation, status.getLocation());
-    Assert.assertEquals("statusCode", TaskState.FAILED, status.getStatusCode());
-    Assert.assertEquals("segments published", 0, mdc.getPublished().size());
-    Assert.assertEquals("segments nuked", 0, mdc.getNuked().size());
+    Assertions.assertEquals(taskLocation, status.getLocation());
+    Assertions.assertEquals(TaskState.FAILED, status.getStatusCode(), "statusCode");
+    Assertions.assertEquals(0, mdc.getPublished().size(), "segments published");
+    Assertions.assertEquals(0, mdc.getNuked().size(), "segments nuked");
   }
 
   private TaskStatus runTask(final Task task)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java
index 2ddd004e583..3bbfef30020 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockBoxConcurrencyTest.java
@@ -47,11 +47,11 @@ import org.apache.druid.segment.metadata.SegmentSchemaManager;
 import org.apache.druid.server.coordinator.simulate.TestDruidLeaderSelector;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.joda.time.Interval;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 import java.util.Collections;
 import java.util.HashSet;
@@ -65,8 +65,7 @@ import java.util.concurrent.atomic.AtomicReference;
 
 public class TaskLockBoxConcurrencyTest
 {
-  @Rule
-  public final TestDerbyConnector.DerbyConnectorRule derby = new TestDerbyConnector.DerbyConnectorRule();
+  private final TestDerbyConnector.DerbyConnectorRule derby = new TestDerbyConnector.DerbyConnectorRule();
 
   private final ObjectMapper objectMapper = new DefaultObjectMapper();
   private ExecutorService service;
@@ -74,9 +73,10 @@ public class TaskLockBoxConcurrencyTest
   private GlobalTaskLockbox lockbox;
   private SegmentSchemaManager segmentSchemaManager;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
+    derby.before();
     final TestDerbyConnector derbyConnector = derby.getConnector();
     derbyConnector.createTaskTables();
     derbyConnector.createPendingSegmentsTable();
@@ -117,10 +117,15 @@ public class TaskLockBoxConcurrencyTest
     service = Execs.multiThreaded(2, "TaskLockBoxConcurrencyTest-%d");
   }
 
-  @After
+  @AfterEach
   public void teardown()
   {
-    service.shutdownNow();
+    try {
+      service.shutdownNow();
+    }
+    finally {
+      derby.after();
+    }
   }
 
   private LockResult tryTimeChunkLock(TaskLockType lockType, Task task, Interval interval)
@@ -134,7 +139,8 @@ public class TaskLockBoxConcurrencyTest
     return lockbox.lock(task, new TimeChunkLockRequest(lockType, task, interval, null));
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testDoInCriticalSectionWithDifferentTasks()
       throws ExecutionException, InterruptedException
   {
@@ -152,8 +158,8 @@ public class TaskLockBoxConcurrencyTest
     // lowPriorityTask acquires a lock first and increases the int of intSupplier in the critical section
     final Future<Integer> lowPriorityFuture = service.submit(() -> {
       final LockResult result = tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval);
-      Assert.assertTrue(result.isOk());
-      Assert.assertFalse(result.isRevoked());
+      Assertions.assertTrue(result.isOk());
+      Assertions.assertFalse(result.isRevoked());
 
       return lockbox.doInCriticalSection(
           lowPriorityTask,
@@ -169,7 +175,7 @@ public class TaskLockBoxConcurrencyTest
               )
               .onInvalidLocks(
                   () -> {
-                    Assert.fail();
+                    Assertions.fail();
                     return null;
                   }
               )
@@ -182,8 +188,8 @@ public class TaskLockBoxConcurrencyTest
     final Future<Integer> highPriorityFuture = service.submit(() -> {
       latch.await();
       final LockResult result = acquireTimeChunkLock(TaskLockType.EXCLUSIVE, highPriorityTask, interval);
-      Assert.assertTrue(result.isOk());
-      Assert.assertFalse(result.isRevoked());
+      Assertions.assertTrue(result.isOk());
+      Assertions.assertFalse(result.isRevoked());
 
       return lockbox.doInCriticalSection(
           highPriorityTask,
@@ -198,7 +204,7 @@ public class TaskLockBoxConcurrencyTest
               )
               .onInvalidLocks(
                   () -> {
-                    Assert.fail();
+                    Assertions.fail();
                     return null;
                   }
               )
@@ -206,16 +212,17 @@ public class TaskLockBoxConcurrencyTest
       );
     });
 
-    Assert.assertEquals(1, lowPriorityFuture.get().intValue());
-    Assert.assertEquals(2, highPriorityFuture.get().intValue());
+    Assertions.assertEquals(1, lowPriorityFuture.get().intValue());
+    Assertions.assertEquals(2, highPriorityFuture.get().intValue());
 
     // the lock for lowPriorityTask must be revoked by the highPriorityTask after its work is done in critical section
     final LockResult result = tryTimeChunkLock(TaskLockType.EXCLUSIVE, lowPriorityTask, interval);
-    Assert.assertFalse(result.isOk());
-    Assert.assertTrue(result.isRevoked());
+    Assertions.assertFalse(result.isOk());
+    Assertions.assertTrue(result.isRevoked());
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testDoInCriticalSectionWithOverlappedIntervals() throws Exception
   {
     final List<Interval> intervals = ImmutableList.of(
@@ -229,7 +236,7 @@ public class TaskLockBoxConcurrencyTest
 
     for (Interval interval : intervals) {
       final LockResult result = tryTimeChunkLock(TaskLockType.EXCLUSIVE, task, interval);
-      Assert.assertTrue(result.isOk());
+      Assertions.assertTrue(result.isOk());
     }
 
     final SettableSupplier<Integer> intSupplier = new SettableSupplier<>(0);
@@ -249,7 +256,7 @@ public class TaskLockBoxConcurrencyTest
             )
             .onInvalidLocks(
                 () -> {
-                  Assert.fail();
+                  Assertions.fail();
                   return null;
                 }
             )
@@ -271,7 +278,7 @@ public class TaskLockBoxConcurrencyTest
               )
               .onInvalidLocks(
                   () -> {
-                    Assert.fail();
+                    Assertions.fail();
                     return null;
                   }
               )
@@ -279,11 +286,12 @@ public class TaskLockBoxConcurrencyTest
       );
     });
 
-    Assert.assertEquals(1, future1.get().intValue());
-    Assert.assertEquals(2, future2.get().intValue());
+    Assertions.assertEquals(1, future1.get().intValue());
+    Assertions.assertEquals(2, future2.get().intValue());
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testConcurrentRemoveAndAllocateSegmentsForSameTask() throws Exception
   {
     final Task task = NoopTask.create();
@@ -369,12 +377,12 @@ public class TaskLockBoxConcurrencyTest
           false
       );
       SegmentAllocateResult result2 = results2.get(0);
-      Assert.assertNull("Subsequent allocation after removal must fail", result2.getSegmentId());
-      Assert.assertFalse(result2.isSuccess());
-      Assert.assertTrue(result2.getErrorMessage().contains("Unable to grant lock to inactive Task"));
+      Assertions.assertNull(result2.getSegmentId(), "Subsequent allocation after removal must fail");
+      Assertions.assertFalse(result2.isSuccess());
+      Assertions.assertTrue(result2.getErrorMessage().contains("Unable to grant lock to inactive Task"));
     } else {
-      Assert.assertTrue(result.getErrorMessage().contains("Unable to grant lock to inactive Task"));
+      Assertions.assertTrue(result.getErrorMessage().contains("Unable to grant lock to inactive Task"));
     }
-    Assert.assertTrue(lockbox.getAllLocks().isEmpty());
+    Assertions.assertTrue(lockbox.getAllLocks().isEmpty());
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockConfigTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockConfigTest.java
index 4936243c886..807cf0479e9 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockConfigTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskLockConfigTest.java
@@ -36,9 +36,9 @@ import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.java.util.emitter.service.ServiceEmitter;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import javax.annotation.Nullable;
 
@@ -46,7 +46,7 @@ public class TaskLockConfigTest
 {
   private TaskStorage taskStorage;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     taskStorage = new HeapMemoryTaskStorage(new TaskStorageConfig(null));
@@ -58,12 +58,12 @@ public class TaskLockConfigTest
     final TaskQueue taskQueue = createTaskQueue(null);
     taskQueue.start();
     final Task task = NoopTask.create();
-    Assert.assertTrue(taskQueue.add(task));
+    Assertions.assertTrue(taskQueue.add(task));
     taskQueue.stop();
     final Optional<Task> optionalTask = taskStorage.getTask(task.getId());
-    Assert.assertTrue(optionalTask.isPresent());
+    Assertions.assertTrue(optionalTask.isPresent());
     final Task fromTaskStorage = optionalTask.get();
-    Assert.assertTrue(fromTaskStorage.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY));
+    Assertions.assertTrue(Boolean.TRUE.equals(fromTaskStorage.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY)));
   }
 
   @Test
@@ -72,12 +72,12 @@ public class TaskLockConfigTest
     final TaskQueue taskQueue = createTaskQueue(false);
     taskQueue.start();
     final Task task = NoopTask.create();
-    Assert.assertTrue(taskQueue.add(task));
+    Assertions.assertTrue(taskQueue.add(task));
     taskQueue.stop();
     final Optional<Task> optionalTask = taskStorage.getTask(task.getId());
-    Assert.assertTrue(optionalTask.isPresent());
+    Assertions.assertTrue(optionalTask.isPresent());
     final Task fromTaskStorage = optionalTask.get();
-    Assert.assertFalse(fromTaskStorage.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY));
+    Assertions.assertFalse(Boolean.TRUE.equals(fromTaskStorage.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY)));
   }
 
   @Test
@@ -87,12 +87,12 @@ public class TaskLockConfigTest
     taskQueue.start();
     final Task task = NoopTask.create();
     task.addToContext(Tasks.FORCE_TIME_CHUNK_LOCK_KEY, false);
-    Assert.assertTrue(taskQueue.add(task));
+    Assertions.assertTrue(taskQueue.add(task));
     taskQueue.stop();
     final Optional<Task> optionalTask = taskStorage.getTask(task.getId());
-    Assert.assertTrue(optionalTask.isPresent());
+    Assertions.assertTrue(optionalTask.isPresent());
     final Task fromTaskStorage = optionalTask.get();
-    Assert.assertFalse(fromTaskStorage.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY));
+    Assertions.assertFalse(Boolean.TRUE.equals(fromTaskStorage.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY)));
   }
 
   private TaskQueue createTaskQueue(@Nullable Boolean forceTimeChunkLock)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueConcurrencyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueConcurrencyTest.java
index f9a1d64c877..6bbab14c469 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueConcurrencyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueConcurrencyTest.java
@@ -37,8 +37,10 @@ import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.concurrent.Execs;
 import org.apache.druid.segment.TestDataSource;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 import java.io.IOException;
 import java.util.HashMap;
@@ -62,6 +64,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
   private Map<String, UpdateAction> threadToUpdateAction;
   private CountDownLatch taskRunnerShutdownLatch;
 
+  @BeforeEach
   @Override
   public void setUpIngestionTestBase() throws IOException
   {
@@ -130,7 +133,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     };
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_start_blocks_add_forAnyTaskId()
   {
     // Add task1 to storage and mark it as running
@@ -143,18 +147,19 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.start()
         ).withEndState(
-            () -> Assert.assertEquals(List.of(task1), taskQueue.getTasks())
+            () -> Assertions.assertEquals(List.of(task1), taskQueue.getTasks())
         )
     ).blocks(
         update(
             () -> taskQueue.add(task2)
         ).withEndState(
-            () -> Assert.assertEquals(List.of(task1, task2), taskQueue.getTasks())
+            () -> Assertions.assertEquals(List.of(task1, task2), taskQueue.getTasks())
         )
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_add_blocks_stop()
   {
     taskQueue.setActive(true);
@@ -164,18 +169,19 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task)
         ).withEndState(
-            () -> Assert.assertEquals(Optional.of(task), taskQueue.getActiveTask(task.getId()))
+            () -> Assertions.assertEquals(Optional.of(task), taskQueue.getActiveTask(task.getId()))
         )
     ).blocks(
         update(
             () -> taskQueue.stop()
         ).withEndState(
-            () -> Assert.assertEquals(Optional.absent(), taskQueue.getActiveTask(task.getId()))
+            () -> Assertions.assertEquals(Optional.absent(), taskQueue.getActiveTask(task.getId()))
         )
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_add_blocks_syncFromStorage_forSameTaskId()
   {
     taskQueue.setActive(true);
@@ -187,18 +193,19 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task)
         ).withEndState(
-            () -> Assert.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId))
+            () -> Assertions.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId))
         )
     ).blocks(
         update(
             () -> taskQueue.syncFromStorage()
         ).withEndState(
-            () -> Assert.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId))
+            () -> Assertions.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId))
         )
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_syncFromStorage_blocks_add_forSameTaskId()
   {
     final String taskId = "t2";
@@ -207,8 +214,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     // Add the task to queue and storage
     taskQueue.setActive(true);
     taskQueue.add(task);
-    Assert.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId));
-    Assert.assertEquals(Optional.of(task), getTaskStorage().getTask(taskId));
+    Assertions.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId));
+    Assertions.assertEquals(Optional.of(task), getTaskStorage().getTask(taskId));
 
     // Mark the task as completed and remove it from storage but not queue
     taskQueue.shutdown(taskId, "test");
@@ -218,18 +225,19 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.syncFromStorage()
         ).withEndState(
-            () -> Assert.assertEquals(Optional.absent(), taskQueue.getActiveTask(taskId))
+            () -> Assertions.assertEquals(Optional.absent(), taskQueue.getActiveTask(taskId))
         )
     ).blocks(
         update(
             () -> taskQueue.add(task)
         ).withEndState(
-            () -> Assert.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId))
+            () -> Assertions.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId))
         )
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_manageQueuedTasks_blocks_shutdown_forSameTaskId()
   {
     final String taskId = "t2";
@@ -237,13 +245,13 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
 
     taskQueue.setActive(true);
     taskQueue.add(task);
-    Assert.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId));
+    Assertions.assertEquals(Optional.of(task), taskQueue.getActiveTask(taskId));
 
     ActionVerifier.verifyThat(
         update(
             () -> taskQueue.manageQueuedTasks()
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(TaskStatus.running(taskId)),
                 taskQueue.getTaskStatus(taskId)
             )
@@ -252,7 +260,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.shutdown(taskId, "test")
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(TaskStatus.failure(taskId, "test")),
                 taskQueue.getTaskStatus(taskId)
             )
@@ -260,7 +268,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_add_blocks_shutdownWithSuccess_forSameTaskId()
   {
     taskQueue.setActive(true);
@@ -272,7 +281,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task)
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(task),
                 taskQueue.getActiveTask(taskId)
             )
@@ -281,7 +290,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.shutdownWithSuccess(task.getId(), "test")
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(TaskStatus.success(taskId)),
                 taskQueue.getTaskStatus(taskId)
             )
@@ -289,7 +298,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_add_blocks_shutdown_forSameTaskId()
   {
     taskQueue.setActive(true);
@@ -301,7 +311,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task)
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(task),
                 taskQueue.getActiveTask(taskId)
             )
@@ -310,7 +320,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.shutdown(task.getId(), "test")
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(TaskStatus.failure(taskId, "test")),
                 taskQueue.getTaskStatus(taskId)
             )
@@ -318,7 +328,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_add_doesNotBlock_add_forDifferentTaskId()
   {
     taskQueue.setActive(true);
@@ -330,7 +341,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task1)
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(task1),
                 taskQueue.getActiveTask(task1.getId())
             )
@@ -339,7 +350,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task2)
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(task2),
                 taskQueue.getActiveTask(task2.getId())
             )
@@ -347,7 +358,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_add_doesNotBlock_shutdown_forDifferentTaskId()
   {
     taskQueue.setActive(true);
@@ -361,7 +373,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task2)
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(task2),
                 taskQueue.getActiveTask(task2.getId())
             )
@@ -370,7 +382,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.shutdown(task1.getId(), "killed")
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(TaskStatus.failure(task1.getId(), "killed")),
                 taskQueue.getTaskStatus(task1.getId())
             )
@@ -378,7 +390,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_shutdown_doesNotBlock_add_forDifferentTaskId()
   {
     taskQueue.setActive(true);
@@ -392,7 +405,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.shutdown(task1.getId(), "killed")
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(TaskStatus.failure(task1.getId(), "killed")),
                 taskQueue.getTaskStatus(task1.getId())
             )
@@ -401,7 +414,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.add(task2)
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(task2),
                 taskQueue.getActiveTask(task2.getId())
             )
@@ -409,7 +422,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     );
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_shutdown_then_manageQueuedTasks_blocks_syncFromStorage_and_forcesTaskRemoval()
   {
     taskQueue.setActive(true);
@@ -426,7 +440,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.manageQueuedTasks()
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.of(TaskStatus.failure(task1.getId(), "shutdown")),
                 taskQueue.getTaskStatus(task1.getId())
             )
@@ -435,17 +449,18 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.syncFromStorage()
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.absent(),
                 taskQueue.getActiveTask(task1.getId())
             )
         )
     );
 
-    Assert.assertEquals(Optional.absent(), taskQueue.getActiveTask(task1.getId()));
+    Assertions.assertEquals(Optional.absent(), taskQueue.getActiveTask(task1.getId()));
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_shutdown_then_syncFromStorage_blocks_manageQueuedTasks_and_forcesTaskRemoval()
   {
     taskQueue.setActive(true);
@@ -462,7 +477,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.syncFromStorage()
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.absent(),
                 taskQueue.getActiveTask(task1.getId())
             )
@@ -471,14 +486,14 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.manageQueuedTasks()
         ).withEndState(
-            () -> Assert.assertEquals(
+            () -> Assertions.assertEquals(
                 Optional.absent(),
                 taskQueue.getActiveTask(task1.getId())
             )
         )
     );
 
-    Assert.assertEquals(Optional.absent(), taskQueue.getActiveTask(task1.getId()));
+    Assertions.assertEquals(Optional.absent(), taskQueue.getActiveTask(task1.getId()));
   }
 
   @Test
@@ -497,13 +512,13 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
         update(
             () -> taskQueue.shutdown(task1.getId(), "killed")
         ).withEndState(
-            () -> Assert.assertEquals(List.of(task1), taskQueue.getTasks())
+            () -> Assertions.assertEquals(List.of(task1), taskQueue.getTasks())
         )
     ).blocks(
         update(
             () -> taskQueue.syncFromStorage()
         ).withEndState(
-            () -> Assert.assertTrue(taskQueue.getTasks().isEmpty())
+            () -> Assertions.assertTrue(taskQueue.getTasks().isEmpty())
         )
     );
   }
@@ -515,7 +530,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
 
     final Task task1 = createTask("t1");
     taskQueue.add(task1);
-    Assert.assertEquals(List.of(task1), taskQueue.getTasks());
+    Assertions.assertEquals(List.of(task1), taskQueue.getTasks());
 
     // Keep the task shutdown blocked on the TaskRunner
     taskRunnerShutdownLatch = new CountDownLatch(1);
@@ -524,8 +539,8 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
     taskQueue.shutdown(task1.getId(), "killed");
 
     Optional<TaskInfo> taskInfo = taskQueue.getActiveTaskInfo(task1.getId());
-    Assert.assertTrue(taskInfo.isPresent());
-    Assert.assertEquals(TaskStatus.failure(task1.getId(), "killed"), taskInfo.get().getStatus());
+    Assertions.assertTrue(taskInfo.isPresent());
+    Assertions.assertEquals(TaskStatus.failure(task1.getId(), "killed"), taskInfo.get().getStatus());
 
     taskRunnerShutdownLatch.countDown();
   }
@@ -556,7 +571,7 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
   {
     try {
       boolean done = latch.await(5, TimeUnit.SECONDS);
-      Assert.assertTrue(StringUtils.format("Latch[%s] is still blocked", latch), done);
+      Assertions.assertTrue(done, StringUtils.format("Latch[%s] is still blocked", latch));
     }
     catch (Exception e) {
       throw new RuntimeException(e);
@@ -754,19 +769,19 @@ public class TaskQueueConcurrencyTest extends IngestionTestBase
       }
 
       // Verify that update 2 is not ready to start critical section yet
-      Assert.assertFalse(update2.isReadyToStartCritical());
+      Assertions.assertFalse(update2.isReadyToStartCritical());
 
       update1.startCritical();
 
       // Wait for update 1 critical to reach finish
       // and verify that update 2 critical is not ready to start yet
       update1.waitUntilCriticalIsReadyToFinish();
-      Assert.assertFalse(update2.isReadyToStartCritical());
+      Assertions.assertFalse(update2.isReadyToStartCritical());
 
       // Finish update 1 critical and verify that update 2 is now ready to start
       update1.finishCritical();
       update2.waitUntilCriticalIsReadyToStart();
-      Assert.assertTrue(update2.isReadyToStartCritical());
+      Assertions.assertTrue(update2.isReadyToStartCritical());
 
       // Finish update 1
       update1.waitToFinishAndVerify();
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java
index 5432326fd3f..04670ba28a3 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueScaleTest.java
@@ -58,11 +58,11 @@ import org.apache.druid.server.coordinator.simulate.TestDruidLeaderSelector;
 import org.apache.druid.server.metrics.NoopServiceEmitter;
 import org.joda.time.Duration;
 import org.joda.time.Period;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
@@ -85,8 +85,8 @@ public class TaskQueueScaleTest
 
   private final int numTasks = 1000;
 
-  @Rule
-  public final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule = new TestDerbyConnector.DerbyConnectorRule();
+  private final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule =
+      new TestDerbyConnector.DerbyConnectorRule();
 
   private TaskQueue taskQueue;
   private TaskStorage taskStorage;
@@ -94,9 +94,10 @@ public class TaskQueueScaleTest
   private Closer closer;
   private SegmentSchemaManager segmentSchemaManager;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
+    derbyConnectorRule.before();
     EmittingLogger.registerEmitter(new NoopServiceEmitter());
 
     closer = Closer.create();
@@ -153,18 +154,24 @@ public class TaskQueueScaleTest
     closer.register(taskQueue::stop);
   }
 
-  @After
+  @AfterEach
   public void tearDown() throws Exception
   {
-    closer.close();
+    try {
+      closer.close();
+    }
+    finally {
+      derbyConnectorRule.after();
+    }
   }
 
-  @Test(timeout = 60_000L) // more than enough time if the task queue is efficient
+  @Timeout(60) // more than enough time if the task queue is efficient
+  @Test
   public void doMassLaunchAndExit() throws Exception
   {
-    Assert.assertEquals("no tasks should be running", 0, taskRunner.getKnownTasks().size());
-    Assert.assertEquals("no tasks should be known", 0, taskQueue.getTasks().size());
-    Assert.assertEquals("no tasks should be running", 0, taskQueue.getRunningTaskCount().size());
+    Assertions.assertEquals(0, taskRunner.getKnownTasks().size(), "no tasks should be running");
+    Assertions.assertEquals(0, taskQueue.getTasks().size(), "no tasks should be known");
+    Assertions.assertEquals(0, taskQueue.getRunningTaskCount().size(), "no tasks should be running");
 
     // Add all tasks.
     for (int i = 0; i < numTasks; i++) {
@@ -173,11 +180,11 @@ public class TaskQueueScaleTest
     }
 
     // in theory we can get a race here, since we fetch the counts at separate times
-    Assert.assertEquals("all tasks should be known", numTasks, taskQueue.getTasks().size());
+    Assertions.assertEquals(numTasks, taskQueue.getTasks().size(), "all tasks should be known");
     long runningTasks = taskQueue.getRunningTaskCount().values().stream().mapToLong(Long::longValue).sum();
     long pendingTasks = taskQueue.getPendingTaskCount().values().stream().mapToLong(Long::longValue).sum();
     long waitingTasks = taskQueue.getWaitingTaskCount().values().stream().mapToLong(Long::longValue).sum();
-    Assert.assertEquals("all tasks should be known", numTasks, (runningTasks + pendingTasks + waitingTasks));
+    Assertions.assertEquals(numTasks, (runningTasks + pendingTasks + waitingTasks), "all tasks should be known");
 
     // Wait for all tasks to finish.
     final TaskLookup.CompleteTaskLookup completeTaskLookup =
@@ -189,19 +196,20 @@ public class TaskQueueScaleTest
 
     Thread.sleep(100);
 
-    Assert.assertEquals("no tasks should be active", 0, taskStorage.getActiveTasks().size());
+    Assertions.assertEquals(0, taskStorage.getActiveTasks().size(), "no tasks should be active");
     runningTasks = taskQueue.getRunningTaskCount().values().stream().mapToLong(Long::longValue).sum();
     pendingTasks = taskQueue.getPendingTaskCount().values().stream().mapToLong(Long::longValue).sum();
     waitingTasks = taskQueue.getWaitingTaskCount().values().stream().mapToLong(Long::longValue).sum();
-    Assert.assertEquals("no tasks should be running", 0, runningTasks);
-    Assert.assertEquals("no tasks should be pending", 0, pendingTasks);
-    Assert.assertEquals("no tasks should be waiting", 0, waitingTasks);
+    Assertions.assertEquals(0, runningTasks, "no tasks should be running");
+    Assertions.assertEquals(0, pendingTasks, "no tasks should be pending");
+    Assertions.assertEquals(0, waitingTasks, "no tasks should be waiting");
   }
 
-  @Test(timeout = 60_000L) // more than enough time if the task queue is efficient
+  @Timeout(60) // more than enough time if the task queue is efficient
+  @Test
   public void doMassLaunchAndShutdown() throws Exception
   {
-    Assert.assertEquals("no tasks should be running", 0, taskRunner.getKnownTasks().size());
+    Assertions.assertEquals(0, taskRunner.getKnownTasks().size(), "no tasks should be running");
 
     // Add all tasks.
     final List<String> taskIds = new ArrayList<>();
@@ -217,7 +225,7 @@ public class TaskQueueScaleTest
     while (taskStorage.getActiveTasks().size() < numTasks) {
       Thread.sleep(100);
     }
-    Assert.assertEquals("all tasks should be running", numTasks, taskStorage.getActiveTasks().size());
+    Assertions.assertEquals(numTasks, taskStorage.getActiveTasks().size(), "all tasks should be running");
 
     // Shut down all tasks.
     for (final String taskId : taskIds) {
@@ -229,13 +237,13 @@ public class TaskQueueScaleTest
       Thread.sleep(100);
     }
 
-    Assert.assertEquals("no tasks should be running", 0, taskStorage.getActiveTasks().size());
+    Assertions.assertEquals(0, taskStorage.getActiveTasks().size(), "no tasks should be running");
 
     int completed = taskStorage.getTaskInfos(
         TaskLookup.CompleteTaskLookup.of(numTasks, Duration.standardHours(1)),
         DATASOURCE
     ).size();
-    Assert.assertEquals("all tasks should have completed", numTasks, completed);
+    Assertions.assertEquals(numTasks, completed, "all tasks should have completed");
   }
 
   private NoopTask createTestTask(long runtimeMillis)
@@ -496,4 +504,3 @@ public class TaskQueueScaleTest
     }
   }
 }
-
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueTest.java
index c09f623ede0..531665027cf 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskQueueTest.java
@@ -90,8 +90,10 @@ import org.apache.druid.server.coordinator.stats.CoordinatorRunStats;
 import org.apache.druid.timeline.DataSegment;
 import org.easymock.EasyMock;
 import org.joda.time.Interval;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 import javax.annotation.Nullable;
 import java.io.IOException;
@@ -113,6 +115,7 @@ public class TaskQueueTest extends IngestionTestBase
   private StubServiceEmitter serviceEmitter;
   private Map<String, Object> defaultTaskContext;
 
+  @BeforeEach
   @Override
   public void setUpIngestionTestBase() throws IOException
   {
@@ -143,7 +146,8 @@ public class TaskQueueTest extends IngestionTestBase
     taskQueue.setActive(true);
   }
 
-  @Test(timeout = 30_000)
+  @Timeout(30)
+  @Test
   public void testManageQueuedTasksReleaseLockWhenTaskIsNotReady() throws Exception
   {
     // task1 emulates a case when there is a task that was issued before task2 and acquired locks conflicting
@@ -151,13 +155,13 @@ public class TaskQueueTest extends IngestionTestBase
     final TestTask task1 = new TestTask("t1", Intervals.of("2021-01/P1M"));
     // Manually get locks for task1. task2 cannot be ready because of task1.
     prepareTaskForLocking(task1);
-    Assert.assertTrue(task1.isReady(actionClientFactory.create(task1)));
+    Assertions.assertTrue(task1.isReady(actionClientFactory.create(task1)));
 
     final TestTask task2 = new TestTask("t2", Intervals.of("2021-01-31/P1M"));
     taskQueue.add(task2);
     taskQueue.manageQueuedTasks();
-    Assert.assertFalse(task2.isDone());
-    Assert.assertTrue(getLockbox().findLocksForTask(task2).isEmpty());
+    Assertions.assertFalse(task2.isDone());
+    Assertions.assertTrue(getLockbox().findLocksForTask(task2).isEmpty());
 
     // task3 can run because task2 is still blocked by task1.
     final TestTask task3 = new TestTask("t3", Intervals.of("2021-02-01/P1M"));
@@ -167,9 +171,9 @@ public class TaskQueueTest extends IngestionTestBase
     // Wait for task3 to exit.
     waitForTaskToExit(task3);
 
-    Assert.assertFalse(task2.isDone());
-    Assert.assertTrue(task3.isDone());
-    Assert.assertTrue(getLockbox().findLocksForTask(task2).isEmpty());
+    Assertions.assertFalse(task2.isDone());
+    Assertions.assertTrue(task3.isDone());
+    Assertions.assertTrue(getLockbox().findLocksForTask(task2).isEmpty());
 
     // Shut down task1 and release its locks.
     shutdownTask(task1);
@@ -177,7 +181,7 @@ public class TaskQueueTest extends IngestionTestBase
     // Now task2 should run.
     taskQueue.manageQueuedTasks();
     waitForTaskToExit(task2);
-    Assert.assertTrue(task2.isDone());
+    Assertions.assertTrue(task2.isDone());
 
     // Sleep to allow all metrics to be emitted
     Thread.sleep(100);
@@ -187,8 +191,8 @@ public class TaskQueueTest extends IngestionTestBase
     verifyFailedTaskCount(taskQueue, 0);
 
     final CoordinatorRunStats stats = taskQueue.getQueueStats();
-    Assert.assertEquals(2, stats.get(Stats.TaskQueue.HANDLED_STATUS_UPDATES));
-    Assert.assertEquals(0, stats.get(Stats.TaskQueue.STATUS_UPDATES_IN_QUEUE));
+    Assertions.assertEquals(2, stats.get(Stats.TaskQueue.HANDLED_STATUS_UPDATES));
+    Assertions.assertEquals(0, stats.get(Stats.TaskQueue.STATUS_UPDATES_IN_QUEUE));
   }
 
   @Test
@@ -205,12 +209,12 @@ public class TaskQueueTest extends IngestionTestBase
     taskQueue.manageQueuedTasks();
 
     // Verify task was NOT started (it should still be incomplete)
-    Assert.assertFalse(task.isDone());
+    Assertions.assertFalse(task.isDone());
 
     // Verify task is still in queue
     final Optional<TaskInfo> taskInfo = taskQueue.getActiveTaskInfo(task.getId());
-    Assert.assertTrue(taskInfo.isPresent());
-    Assert.assertEquals(TaskState.RUNNING, taskInfo.get().getStatus().getStatusCode());
+    Assertions.assertTrue(taskInfo.isPresent());
+    Assertions.assertEquals(TaskState.RUNNING, taskInfo.get().getStatus().getStatusCode());
 
     // Verify no metrics were emitted since no tasks were processed
     serviceEmitter.verifyNotEmitted("task/waiting/time");
@@ -231,18 +235,18 @@ public class TaskQueueTest extends IngestionTestBase
         new TimeChunkLockRequest(TaskLockType.EXCLUSIVE, task, task.interval, null)
     );
     final List<TaskLock> locksForTask = getLockbox().findLocksForTask(task);
-    Assert.assertEquals(1, locksForTask.size());
-    Assert.assertEquals(task.interval, locksForTask.get(0).getInterval());
+    Assertions.assertEquals(1, locksForTask.size());
+    Assertions.assertEquals(task.interval, locksForTask.get(0).getInterval());
 
     // Verify that locks are removed on calling shutdown
     taskQueue.shutdown(task.getId(), "Shutdown Task test");
-    Assert.assertTrue(getLockbox().findLocksForTask(task).isEmpty());
+    Assertions.assertTrue(getLockbox().findLocksForTask(task).isEmpty());
 
     Optional<TaskStatus> statusOptional = getTaskStorage().getStatus(task.getId());
-    Assert.assertTrue(statusOptional.isPresent());
-    Assert.assertEquals(TaskState.FAILED, statusOptional.get().getStatusCode());
-    Assert.assertNotNull(statusOptional.get().getErrorMsg());
-    Assert.assertEquals("Shutdown Task test", statusOptional.get().getErrorMsg());
+    Assertions.assertTrue(statusOptional.isPresent());
+    Assertions.assertEquals(TaskState.FAILED, statusOptional.get().getStatusCode());
+    Assertions.assertNotNull(statusOptional.get().getErrorMsg());
+    Assertions.assertEquals("Shutdown Task test", statusOptional.get().getErrorMsg());
   }
 
   @Test
@@ -254,7 +258,7 @@ public class TaskQueueTest extends IngestionTestBase
     }
 
     // Verify that adding another task throws an exception
-    Assert.assertThrows(
+    Assertions.assertThrows(
         DruidException.class,
         () -> taskQueue.add(new TestTask("tx", Intervals.of("2021-01/P1M")))
     );
@@ -302,7 +306,7 @@ public class TaskQueueTest extends IngestionTestBase
     char[] contextLarge = new char[100 * 1024 * 1024];
     Arrays.fill(contextLarge, 'a');
 
-    Assert.assertThrows(
+    Assertions.assertThrows(
         DruidException.class,
         () -> maxPayloadTaskQueue.add(
             new TestTask(
@@ -334,10 +338,12 @@ public class TaskQueueTest extends IngestionTestBase
     taskQueue.add(task);
 
     final List<Task> tasks = taskQueue.getTasks();
-    Assert.assertEquals(1, tasks.size());
+    Assertions.assertEquals(1, tasks.size());
     final Task queuedTask = tasks.get(0);
-    Assert.assertTrue(
-        queuedTask.getContextValue(SinglePhaseParallelIndexTaskRunner.CTX_USE_LINEAGE_BASED_SEGMENT_ALLOCATION_KEY)
+    Assertions.assertTrue(
+        Boolean.TRUE.equals(
+            queuedTask.getContextValue(SinglePhaseParallelIndexTaskRunner.CTX_USE_LINEAGE_BASED_SEGMENT_ALLOCATION_KEY)
+        )
     );
   }
 
@@ -351,10 +357,12 @@ public class TaskQueueTest extends IngestionTestBase
     final Task task = new TestTask("t1", Intervals.of("2021-01-01/P1D"));
     taskQueue.add(task);
     final List<Task> tasks = taskQueue.getTasks();
-    Assert.assertEquals(1, tasks.size());
+    Assertions.assertEquals(1, tasks.size());
     final Task queuedTask = tasks.get(0);
-    Assert.assertFalse(
-        queuedTask.getContextValue(SinglePhaseParallelIndexTaskRunner.CTX_USE_LINEAGE_BASED_SEGMENT_ALLOCATION_KEY)
+    Assertions.assertFalse(
+        Boolean.TRUE.equals(
+            queuedTask.getContextValue(SinglePhaseParallelIndexTaskRunner.CTX_USE_LINEAGE_BASED_SEGMENT_ALLOCATION_KEY)
+        )
     );
   }
 
@@ -371,10 +379,12 @@ public class TaskQueueTest extends IngestionTestBase
     );
     taskQueue.add(task);
     final List<Task> tasks = taskQueue.getTasks();
-    Assert.assertEquals(1, tasks.size());
+    Assertions.assertEquals(1, tasks.size());
     final Task queuedTask = tasks.get(0);
-    Assert.assertFalse(
-        queuedTask.getContextValue(SinglePhaseParallelIndexTaskRunner.CTX_USE_LINEAGE_BASED_SEGMENT_ALLOCATION_KEY)
+    Assertions.assertFalse(
+        Boolean.TRUE.equals(
+            queuedTask.getContextValue(SinglePhaseParallelIndexTaskRunner.CTX_USE_LINEAGE_BASED_SEGMENT_ALLOCATION_KEY)
+        )
     );
   }
 
@@ -385,9 +395,9 @@ public class TaskQueueTest extends IngestionTestBase
     final Task task = new TestTask("t1", Intervals.of("2021-01-01/P1D"));
     taskQueue.add(task);
     final List<Task> tasks = taskQueue.getTasks();
-    Assert.assertEquals(1, tasks.size());
+    Assertions.assertEquals(1, tasks.size());
     final Task queuedTask = tasks.get(0);
-    Assert.assertTrue(queuedTask.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY));
+    Assertions.assertTrue(Boolean.TRUE.equals(queuedTask.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY)));
   }
 
   @Test
@@ -403,9 +413,9 @@ public class TaskQueueTest extends IngestionTestBase
     );
     taskQueue.add(task);
     final List<Task> tasks = taskQueue.getTasks();
-    Assert.assertEquals(1, tasks.size());
+    Assertions.assertEquals(1, tasks.size());
     final Task queuedTask = tasks.get(0);
-    Assert.assertFalse(queuedTask.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY));
+    Assertions.assertFalse(Boolean.TRUE.equals(queuedTask.getContextValue(Tasks.FORCE_TIME_CHUNK_LOCK_KEY)));
   }
 
   @Test
@@ -424,10 +434,10 @@ public class TaskQueueTest extends IngestionTestBase
     taskQueue.manageQueuedTasks();
 
     Optional<TaskStatus> statusOptional = getTaskStorage().getStatus(task.getId());
-    Assert.assertTrue(statusOptional.isPresent());
-    Assert.assertEquals(TaskState.FAILED, statusOptional.get().getStatusCode());
-    Assert.assertNotNull(statusOptional.get().getErrorMsg());
-    Assert.assertTrue(
+    Assertions.assertTrue(statusOptional.isPresent());
+    Assertions.assertEquals(TaskState.FAILED, statusOptional.get().getStatusCode());
+    Assertions.assertNotNull(statusOptional.get().getErrorMsg());
+    Assertions.assertTrue(
         statusOptional.get().getErrorMsg().contains(exceptionMsg)
     );
 
@@ -436,8 +446,8 @@ public class TaskQueueTest extends IngestionTestBase
     verifyFailedTaskCount(taskQueue, 1);
 
     final CoordinatorRunStats stats = taskQueue.getQueueStats();
-    Assert.assertEquals(0, stats.get(Stats.TaskQueue.HANDLED_STATUS_UPDATES));
-    Assert.assertEquals(0, stats.get(Stats.TaskQueue.STATUS_UPDATES_IN_QUEUE));
+    Assertions.assertEquals(0, stats.get(Stats.TaskQueue.HANDLED_STATUS_UPDATES));
+    Assertions.assertEquals(0, stats.get(Stats.TaskQueue.STATUS_UPDATES_IN_QUEUE));
   }
 
   @Test
@@ -498,8 +508,8 @@ public class TaskQueueTest extends IngestionTestBase
     verifyFailedTaskCount(taskQueue, 1);
 
     final CoordinatorRunStats stats = taskQueue.getQueueStats();
-    Assert.assertEquals(1, stats.get(Stats.TaskQueue.HANDLED_STATUS_UPDATES));
-    Assert.assertEquals(0, stats.get(Stats.TaskQueue.STATUS_UPDATES_IN_QUEUE));
+    Assertions.assertEquals(1, stats.get(Stats.TaskQueue.HANDLED_STATUS_UPDATES));
+    Assertions.assertEquals(0, stats.get(Stats.TaskQueue.STATUS_UPDATES_IN_QUEUE));
   }
 
   @Test
@@ -510,17 +520,17 @@ public class TaskQueueTest extends IngestionTestBase
 
     // Active task: status should come from activeTasks map
     final Optional<TaskStatus> activeStatus = taskQueue.getTaskStatus(task.getId());
-    Assert.assertTrue(activeStatus.isPresent());
-    Assert.assertEquals(TaskState.RUNNING, activeStatus.get().getStatusCode());
-    Assert.assertEquals(task.getId(), activeStatus.get().getId());
+    Assertions.assertTrue(activeStatus.isPresent());
+    Assertions.assertEquals(TaskState.RUNNING, activeStatus.get().getStatusCode());
+    Assertions.assertEquals(task.getId(), activeStatus.get().getId());
 
     // Run the task so it completes
     taskQueue.manageQueuedTasks();
     waitForTaskToExit(task);
 
     final Optional<TaskStatus> completedStatus = taskQueue.getTaskStatus(task.getId());
-    Assert.assertTrue(completedStatus.isPresent());
-    Assert.assertEquals(TaskState.SUCCESS, completedStatus.get().getStatusCode());
+    Assertions.assertTrue(completedStatus.isPresent());
+    Assertions.assertEquals(TaskState.SUCCESS, completedStatus.get().getStatusCode());
   }
 
   @Test
@@ -540,16 +550,16 @@ public class TaskQueueTest extends IngestionTestBase
     waitForTaskToExit(task);
 
     final Optional<TaskStatus> failedStatus = taskQueue.getTaskStatus(task.getId());
-    Assert.assertTrue(failedStatus.isPresent());
-    Assert.assertEquals(TaskState.FAILED, failedStatus.get().getStatusCode());
-    Assert.assertEquals("intentional failure", failedStatus.get().getErrorMsg());
+    Assertions.assertTrue(failedStatus.isPresent());
+    Assertions.assertEquals(TaskState.FAILED, failedStatus.get().getStatusCode());
+    Assertions.assertEquals("intentional failure", failedStatus.get().getErrorMsg());
   }
 
   @Test
   public void testGetTaskStatus_unknownTask()
   {
     final Optional<TaskStatus> unknownStatus = taskQueue.getTaskStatus("unknownTask");
-    Assert.assertFalse(unknownStatus.isPresent());
+    Assertions.assertFalse(unknownStatus.isPresent());
   }
 
   @Test
@@ -621,22 +631,22 @@ public class TaskQueueTest extends IngestionTestBase
         null,
         false
     );
-    Assert.assertTrue(mapper.writeValueAsString(taskWithPassword).contains(password));
+    Assertions.assertTrue(mapper.writeValueAsString(taskWithPassword).contains(password));
 
     taskQueue.start();
     taskQueue.add(taskWithPassword);
 
     final Optional<Task> taskInStorage = taskStorage.getTask(taskWithPassword.getId());
-    Assert.assertTrue(taskInStorage.isPresent());
+    Assertions.assertTrue(taskInStorage.isPresent());
     final String taskInStorageAsString = mapper.writeValueAsString(taskInStorage.get());
-    Assert.assertFalse(taskInStorageAsString.contains(password));
+    Assertions.assertFalse(taskInStorageAsString.contains(password));
 
     final Optional<Task> taskInQueue = taskQueue.getActiveTask(taskWithPassword.getId());
-    Assert.assertTrue(taskInQueue.isPresent());
+    Assertions.assertTrue(taskInQueue.isPresent());
     final String taskInQueueAsString = mapper.writeValueAsString(taskInQueue.get());
-    Assert.assertFalse(taskInQueueAsString.contains(password));
+    Assertions.assertFalse(taskInQueueAsString.contains(password));
 
-    Assert.assertEquals(taskInStorageAsString, taskInQueueAsString);
+    Assertions.assertEquals(taskInStorageAsString, taskInQueueAsString);
   }
 
   @Test
@@ -648,15 +658,15 @@ public class TaskQueueTest extends IngestionTestBase
     taskQueue.add(task);
 
     final Optional<TaskInfo> activeInfoOpt = taskQueue.getActiveTaskInfo(task.getId());
-    Assert.assertTrue(activeInfoOpt.isPresent());
-    Assert.assertEquals(TaskState.RUNNING, activeInfoOpt.get().getStatus().getStatusCode());
+    Assertions.assertTrue(activeInfoOpt.isPresent());
+    Assertions.assertEquals(TaskState.RUNNING, activeInfoOpt.get().getStatus().getStatusCode());
 
     taskQueue.shutdown(task.getId(), shutdownReason);
 
     final Optional<TaskInfo> afterShutdownInfoOpt = taskQueue.getActiveTaskInfo(task.getId());
-    Assert.assertTrue(afterShutdownInfoOpt.isPresent());
-    Assert.assertEquals(shutdownStatus, afterShutdownInfoOpt.get().getStatus());
-    Assert.assertEquals(shutdownStatus, getTaskStorage().getStatus(task.getId()).get());
+    Assertions.assertTrue(afterShutdownInfoOpt.isPresent());
+    Assertions.assertEquals(shutdownStatus, afterShutdownInfoOpt.get().getStatus());
+    Assertions.assertEquals(shutdownStatus, getTaskStorage().getStatus(task.getId()).get());
   }
 
   @Test
@@ -669,12 +679,12 @@ public class TaskQueueTest extends IngestionTestBase
 
     // ensure success callback has fired
     Thread.sleep(100);
-    Assert.assertTrue(task.isDone());
+    Assertions.assertTrue(task.isDone());
 
     final Optional<TaskInfo> activeInfoOpt = taskQueue.getActiveTaskInfo(task.getId());
-    Assert.assertTrue(activeInfoOpt.isPresent());
-    Assert.assertEquals(successStatus, activeInfoOpt.get().getStatus());
-    Assert.assertEquals(successStatus, getTaskStorage().getStatus(task.getId()).get());
+    Assertions.assertTrue(activeInfoOpt.isPresent());
+    Assertions.assertEquals(successStatus, activeInfoOpt.get().getStatus());
+    Assertions.assertEquals(successStatus, getTaskStorage().getStatus(task.getId()).get());
   }
 
   @Test
@@ -696,12 +706,12 @@ public class TaskQueueTest extends IngestionTestBase
 
     // ensure failed callback has fired
     Thread.sleep(100);
-    Assert.assertTrue(task.isDone());
+    Assertions.assertTrue(task.isDone());
 
     final Optional<TaskInfo> activeInfoOpt = taskQueue.getActiveTaskInfo(task.getId());
-    Assert.assertTrue(activeInfoOpt.isPresent());
-    Assert.assertEquals(failedStatus, activeInfoOpt.get().getStatus());
-    Assert.assertEquals(failedStatus, getTaskStorage().getStatus(task.getId()).get());
+    Assertions.assertTrue(activeInfoOpt.isPresent());
+    Assertions.assertEquals(failedStatus, activeInfoOpt.get().getStatus());
+    Assertions.assertEquals(failedStatus, getTaskStorage().getStatus(task.getId()).get());
   }
 
   @Test
@@ -710,7 +720,7 @@ public class TaskQueueTest extends IngestionTestBase
     // task1 acquires a lock that will block task2
     final TestTask task1 = new TestTask("t1", Intervals.of("2021-01/P1M"));
     prepareTaskForLocking(task1);
-    Assert.assertTrue(task1.isReady(actionClientFactory.create(task1)));
+    Assertions.assertTrue(task1.isReady(actionClientFactory.create(task1)));
 
     // task2 will not be ready because of task1's lock
     final TestTask task2 = new TestTask("t2", Intervals.of("2021-01-31/P1M"));
@@ -785,12 +795,12 @@ public class TaskQueueTest extends IngestionTestBase
     priorityQueue.manageQueuedTasks();
 
     final List<String> submitted = recordingRunner.getSubmittedTaskIds();
-    Assert.assertEquals(5, submitted.size());
-    Assert.assertEquals(highPriority2.getId(), submitted.get(0));
-    Assert.assertEquals(highPriority1.getId(), submitted.get(1));
-    Assert.assertEquals(medPriority.getId(), submitted.get(2));
-    Assert.assertEquals(lowPriority2.getId(), submitted.get(3));
-    Assert.assertEquals(lowPriority1.getId(), submitted.get(4));
+    Assertions.assertEquals(5, submitted.size());
+    Assertions.assertEquals(highPriority2.getId(), submitted.get(0));
+    Assertions.assertEquals(highPriority1.getId(), submitted.get(1));
+    Assertions.assertEquals(medPriority.getId(), submitted.get(2));
+    Assertions.assertEquals(lowPriority2.getId(), submitted.get(3));
+    Assertions.assertEquals(lowPriority1.getId(), submitted.get(4));
   }
 
   private HttpRemoteTaskRunner createHttpRemoteTaskRunner()
@@ -827,7 +837,7 @@ public class TaskQueueTest extends IngestionTestBase
 
   private static void verifySuccessfulTaskCount(final TaskQueue taskQueue, int successCount)
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         successCount,
         taskQueue.getSuccessfulTaskCount().values().stream().mapToLong(Long::longValue).sum()
     );
@@ -835,7 +845,7 @@ public class TaskQueueTest extends IngestionTestBase
 
   private static void verifyFailedTaskCount(final TaskQueue taskQueue, int failureCount)
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         failureCount,
         taskQueue.getFailedTaskCount().values().stream().mapToLong(Long::longValue).sum()
     );
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskRunnerUtilsTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskRunnerUtilsTest.java
index 0bc4176facd..8152484b984 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskRunnerUtilsTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskRunnerUtilsTest.java
@@ -34,8 +34,8 @@ import org.easymock.EasyMock;
 import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
 import org.jboss.netty.handler.codec.http.HttpResponseStatus;
 import org.jboss.netty.handler.codec.http.HttpVersion;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -52,9 +52,9 @@ public class TaskRunnerUtilsTest
         "/druid/worker/v1/task/%s/log",
         "foo bar&"
     );
-    Assert.assertEquals("https://1.2.3.4:8290/druid/worker/v1/task/foo%20bar%26/log", url.toString());
-    Assert.assertEquals("1.2.3.4:8290", url.getAuthority());
-    Assert.assertEquals("/druid/worker/v1/task/foo%20bar%26/log", url.getPath());
+    Assertions.assertEquals("https://1.2.3.4:8290/druid/worker/v1/task/foo%20bar%26/log", url.toString());
+    Assertions.assertEquals("1.2.3.4:8290", url.getAuthority());
+    Assertions.assertEquals("/druid/worker/v1/task/foo%20bar%26/log", url.getPath());
   }
 
   @Test
@@ -65,7 +65,7 @@ public class TaskRunnerUtilsTest
         "/druid/worker/v1/task/%s/log",
         "foo bar&"
     );
-    Assert.assertEquals("https://1.2.3.4:8290/druid/worker/v1/task/foo%20bar%26/log", url.toString());
+    Assertions.assertEquals("https://1.2.3.4:8290/druid/worker/v1/task/foo%20bar%26/log", url.toString());
   }
 
   @Test
@@ -82,8 +82,8 @@ public class TaskRunnerUtilsTest
         url("http://example.com/liveReports")
     );
 
-    Assert.assertTrue(stream.isPresent());
-    Assert.assertEquals(report, StringUtils.fromUtf8(ByteStreams.toByteArray(stream.get())));
+    Assertions.assertTrue(stream.isPresent());
+    Assertions.assertEquals(report, StringUtils.fromUtf8(ByteStreams.toByteArray(stream.get())));
     EasyMock.verify(httpClient);
   }
 
@@ -107,7 +107,7 @@ public class TaskRunnerUtilsTest
             .andReturn(Futures.immediateFuture(response(HttpResponseStatus.INTERNAL_SERVER_ERROR, "error")));
     EasyMock.replay(httpClient);
 
-    final IOException e = Assert.assertThrows(
+    final IOException e = Assertions.assertThrows(
         IOException.class,
         () -> TaskRunnerUtils.streamTaskReportsFromTaskLocation(
             httpClient,
@@ -115,7 +115,7 @@ public class TaskRunnerUtilsTest
         )
     );
 
-    Assert.assertTrue(e.getMessage().contains("500 Internal Server Error"));
+    Assertions.assertTrue(e.getMessage().contains("500 Internal Server Error"));
     EasyMock.verify(httpClient);
   }
 
@@ -128,7 +128,7 @@ public class TaskRunnerUtilsTest
             .andReturn(Futures.immediateFuture(response(status, "error")));
     EasyMock.replay(httpClient);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Optional.absent(),
         TaskRunnerUtils.streamTaskReportsFromTaskLocation(httpClient, url("http://example.com/liveReports"))
     );
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskStorageUtilsTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskStorageUtilsTest.java
index a696925fbce..5a0ff28083c 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskStorageUtilsTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/TaskStorageUtilsTest.java
@@ -22,15 +22,15 @@ package org.apache.druid.indexing.overlord;
 import com.google.common.collect.ImmutableMap;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.metadata.TaskLookup;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class TaskStorageUtilsTest
 {
   @Test
   public void test_processTaskLookups_defaultLimit_defaultTime()
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableMap.of(
             TaskLookup.TaskLookupType.ACTIVE,
             TaskLookup.ActiveTaskLookup.getInstance(),
@@ -52,7 +52,7 @@ public class TaskStorageUtilsTest
   @Test
   public void test_processTaskLookups_zeroCompleteTasks_defaultTime()
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableMap.of(
             TaskLookup.TaskLookupType.ACTIVE,
             TaskLookup.ActiveTaskLookup.getInstance()
@@ -72,7 +72,7 @@ public class TaskStorageUtilsTest
   @Test
   public void test_processTaskLookups_oneCompleteTask_3000()
   {
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableMap.of(
             TaskLookup.TaskLookupType.ACTIVE,
             TaskLookup.ActiveTaskLookup.getInstance(),
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ThreadingTaskRunnerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ThreadingTaskRunnerTest.java
index 3f51af2747a..968051d9339 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ThreadingTaskRunnerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/ThreadingTaskRunnerTest.java
@@ -37,9 +37,9 @@ import org.apache.druid.java.util.common.StringUtils;
 import org.apache.druid.java.util.common.logger.Logger;
 import org.apache.druid.server.DruidNode;
 import org.apache.druid.tasklogs.NoopTaskLogs;
-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.io.InputStream;
 import java.nio.charset.StandardCharsets;
@@ -54,7 +54,7 @@ public class ThreadingTaskRunnerTest
 
   private ThreadingTaskRunner runner;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     final TaskConfig taskConfig = ForkingTaskRunnerTest.makeDefaultTaskConfigBuilder().build();
@@ -84,9 +84,9 @@ public class ThreadingTaskRunnerTest
       }
     });
 
-    TaskStatus status = statusFuture.get();
-    Assert.assertEquals(TaskState.FAILED, status.getStatusCode());
-    Assert.assertEquals(
+    final TaskStatus status = statusFuture.get();
+    Assertions.assertEquals(TaskState.FAILED, status.getStatusCode());
+    Assertions.assertEquals(
         "Failed with exception [Task failure test]. See indexer logs for details.",
         status.getErrorMsg()
     );
@@ -117,11 +117,11 @@ public class ThreadingTaskRunnerTest
 
     // Stream and verify the contents of the task logs
     final Optional<InputStream> logStream = runner.streamTaskLog(indexerTask.getId(), 0);
-    Assert.assertTrue(logStream.isPresent());
+    Assertions.assertTrue(logStream.isPresent());
 
     try (final InputStream in = logStream.get()) {
       final String fullTaskLogs = IOUtils.toString(in, StandardCharsets.UTF_8);
-      Assert.assertTrue(
+      Assertions.assertTrue(
           fullTaskLogs.contains(
               StringUtils.format("Running test task[%s]", indexerTask.getId())
           )
@@ -130,13 +130,13 @@ public class ThreadingTaskRunnerTest
 
     // Finish the task and verify status
     finishTask.countDown();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         TaskStatus.success(indexerTask.getId()),
         statusFuture.get()
     );
 
     // Verify that task logs cannot be streamed anymore as task has finished
-    Assert.assertFalse(
+    Assertions.assertFalse(
         runner.streamTaskLog(indexerTask.getId(), 0).isPresent()
     );
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/WorkerTaskRunnerQueryAdpaterTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/WorkerTaskRunnerQueryAdpaterTest.java
index 4bb1c9b24d8..9d410408da9 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/WorkerTaskRunnerQueryAdpaterTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/WorkerTaskRunnerQueryAdpaterTest.java
@@ -35,10 +35,10 @@ import org.easymock.Capture;
 import org.easymock.EasyMock;
 import org.jboss.netty.handler.codec.http.HttpMethod;
 import org.jboss.netty.handler.codec.http.HttpResponseStatus;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.net.URL;
 
@@ -50,7 +50,7 @@ public class WorkerTaskRunnerQueryAdpaterTest
   private WorkerTaskRunner workerTaskRunner;
   private TaskMaster taskMaster;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     httpClient = EasyMock.createNiceMock(HttpClient.class);
@@ -87,7 +87,7 @@ public class WorkerTaskRunnerQueryAdpaterTest
     ).once();
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     EasyMock.verify(workerTaskRunner, taskMaster, httpClient);
@@ -104,8 +104,8 @@ public class WorkerTaskRunnerQueryAdpaterTest
 
     workerTaskRunnerQueryAdapter.disableWorker("worker-host1");
 
-    Assert.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
-    Assert.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
+    Assertions.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
+    Assertions.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
   }
 
   @Test
@@ -116,23 +116,24 @@ public class WorkerTaskRunnerQueryAdpaterTest
 
     EasyMock.replay(workerTaskRunner, taskMaster, httpClient);
 
-    try {
-      workerTaskRunnerQueryAdapter.disableWorker("worker-host1");
-      Assert.fail("Should raise RE exception!");
-    }
-    catch (RE re) {
-    }
+    Assertions.assertThrows(
+        RE.class,
+        () -> workerTaskRunnerQueryAdapter.disableWorker("worker-host1")
+    );
 
-    Assert.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
-    Assert.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
+    Assertions.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
+    Assertions.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
   }
 
-  @Test(expected = RE.class)
+  @Test
   public void testDisableWorkerWhenWorkerNotExists()
   {
     EasyMock.replay(workerTaskRunner, taskMaster, httpClient);
 
-    workerTaskRunnerQueryAdapter.disableWorker("not-existing-worker");
+    Assertions.assertThrows(
+        RE.class,
+        () -> workerTaskRunnerQueryAdapter.disableWorker("not-existing-worker")
+    );
   }
 
   @Test
@@ -146,8 +147,8 @@ public class WorkerTaskRunnerQueryAdpaterTest
 
     workerTaskRunnerQueryAdapter.enableWorker("worker-host2");
 
-    Assert.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
-    Assert.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
+    Assertions.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
+    Assertions.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
   }
 
   @Test
@@ -158,23 +159,24 @@ public class WorkerTaskRunnerQueryAdpaterTest
 
     EasyMock.replay(workerTaskRunner, taskMaster, httpClient);
 
-    try {
-      workerTaskRunnerQueryAdapter.enableWorker("worker-host2");
-      Assert.fail("Should raise RE exception!");
-    }
-    catch (RE re) {
-    }
+    Assertions.assertThrows(
+        RE.class,
+        () -> workerTaskRunnerQueryAdapter.enableWorker("worker-host2")
+    );
 
-    Assert.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
-    Assert.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
+    Assertions.assertEquals(HttpMethod.POST, capturedRequest.getValue().getMethod());
+    Assertions.assertEquals(workerUrl, capturedRequest.getValue().getUrl());
   }
 
-  @Test(expected = RE.class)
+  @Test
   public void testEnableWorkerWhenWorkerNotExists()
   {
     EasyMock.replay(workerTaskRunner, taskMaster, httpClient);
 
-    workerTaskRunnerQueryAdapter.enableWorker("not-existing-worker");
+    Assertions.assertThrows(
+        RE.class,
+        () -> workerTaskRunnerQueryAdapter.enableWorker("not-existing-worker")
+    );
   }
 
   private Capture<Request> getHttpClientRequestCapture(HttpResponseStatus httpStatus, String responseContent)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java
index 69867b1ba38..786bec6d97e 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/PendingTaskBasedProvisioningStrategyTest.java
@@ -47,9 +47,9 @@ import org.easymock.Capture;
 import org.easymock.EasyMock;
 import org.joda.time.DateTime;
 import org.joda.time.Period;
-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.ArrayList;
 import java.util.Arrays;
@@ -74,7 +74,7 @@ public class PendingTaskBasedProvisioningStrategyTest
   private static final String MIN_VERSION = "2014-01-00T00:01:00Z";
   private static final String INVALID_VERSION = "0";
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     autoScaler = EasyMock.createMock(AutoScaler.class);
@@ -135,7 +135,7 @@ public class PendingTaskBasedProvisioningStrategyTest
         }
     );
     int expectedWorkerCapacity = strategy.getExpectedWorkerCapacity(ImmutableList.of());
-    Assert.assertEquals(capacityHint, expectedWorkerCapacity);
+    Assertions.assertEquals(capacityHint, expectedWorkerCapacity);
   }
 
   @Test
@@ -163,7 +163,7 @@ public class PendingTaskBasedProvisioningStrategyTest
         }
     );
     int expectedWorkerCapacity = strategy.getExpectedWorkerCapacity(ImmutableList.of());
-    Assert.assertEquals(1, expectedWorkerCapacity);
+    Assertions.assertEquals(1, expectedWorkerCapacity);
   }
 
   @Test
@@ -179,7 +179,7 @@ public class PendingTaskBasedProvisioningStrategyTest
         )
     );
     int expectedWorkerCapacity = strategy.getExpectedWorkerCapacity(workerInfoCollection);
-    Assert.assertEquals(workerCapacity, expectedWorkerCapacity);
+    Assertions.assertEquals(workerCapacity, expectedWorkerCapacity);
   }
 
   @Test
@@ -203,7 +203,7 @@ public class PendingTaskBasedProvisioningStrategyTest
     );
     int expectedWorkerCapacity = strategy.getExpectedWorkerCapacity(workerInfoCollection);
     // Use capacity of the first worker in the list
-    Assert.assertEquals(workerOneCapacity, expectedWorkerCapacity);
+    Assertions.assertEquals(workerOneCapacity, expectedWorkerCapacity);
   }
 
   @Test
@@ -227,8 +227,8 @@ public class PendingTaskBasedProvisioningStrategyTest
         "test",
         mockLogger
     );
-    Assert.assertNull(defaultWorkerBehaviorConfig);
-    Assert.assertEquals(PendingTaskBasedWorkerProvisioningStrategy.ERROR_MESSAGE_MIN_WORKER_ZERO_HINT_UNSET, capturedArgument.getValue());
+    Assertions.assertNull(defaultWorkerBehaviorConfig);
+    Assertions.assertEquals(PendingTaskBasedWorkerProvisioningStrategy.ERROR_MESSAGE_MIN_WORKER_ZERO_HINT_UNSET, capturedArgument.getValue());
   }
 
   @Test
@@ -253,10 +253,10 @@ public class PendingTaskBasedProvisioningStrategyTest
     EasyMock.replay(runner, autoScaler);
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 3);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 3);
     for (ScalingStats.ScalingEvent event : provisioner.getStats().toList()) {
-      Assert.assertTrue(
+      Assertions.assertTrue(
           event.getEvent() == ScalingStats.EVENT.PROVISION
       );
     }
@@ -304,10 +304,10 @@ public class PendingTaskBasedProvisioningStrategyTest
     EasyMock.replay(runner, autoScaler);
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 3);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 3);
     for (ScalingStats.ScalingEvent event : provisioner.getStats().toList()) {
-      Assert.assertTrue(
+      Assertions.assertTrue(
           event.getEvent() == ScalingStats.EVENT.PROVISION
       );
     }
@@ -353,8 +353,8 @@ public class PendingTaskBasedProvisioningStrategyTest
     EasyMock.replay(runner, autoScaler);
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
-    Assert.assertFalse(provisionedSomething);
-    Assert.assertEquals(0, provisioner.getStats().toList().size());
+    Assertions.assertFalse(provisionedSomething);
+    Assertions.assertEquals(0, provisioner.getStats().toList().size());
   }
 
   @Test
@@ -382,10 +382,10 @@ public class PendingTaskBasedProvisioningStrategyTest
     EasyMock.replay(runner, autoScaler);
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 2);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 2);
     for (ScalingStats.ScalingEvent event : provisioner.getStats().toList()) {
-      Assert.assertTrue(
+      Assertions.assertTrue(
           event.getEvent() == ScalingStats.EVENT.PROVISION
       );
     }
@@ -417,10 +417,10 @@ public class PendingTaskBasedProvisioningStrategyTest
     EasyMock.replay(runner, autoScaler);
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 2);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 2);
     for (ScalingStats.ScalingEvent event : provisioner.getStats().toList()) {
-      Assert.assertTrue(
+      Assertions.assertTrue(
           event.getEvent() == ScalingStats.EVENT.PROVISION
       );
     }
@@ -455,21 +455,21 @@ public class PendingTaskBasedProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
     DateTime createdTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
 
     provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
-    Assert.assertTrue(
+    Assertions.assertFalse(provisionedSomething);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
     DateTime anotherCreatedTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         createdTime.equals(anotherCreatedTime)
     );
 
@@ -531,20 +531,20 @@ public class PendingTaskBasedProvisioningStrategyTest
 
     // Expect to use capacity from current worker (which is 1)
     // and since there are two pending tasks, we will need two more workers
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertEquals(2, provisioner.getStats().toList().size());
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertEquals(2, provisioner.getStats().toList().size());
     DateTime createdTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertEquals(ScalingStats.EVENT.PROVISION, provisioner.getStats().toList().get(0).getEvent());
-    Assert.assertEquals(ScalingStats.EVENT.PROVISION, provisioner.getStats().toList().get(1).getEvent());
+    Assertions.assertEquals(ScalingStats.EVENT.PROVISION, provisioner.getStats().toList().get(0).getEvent());
+    Assertions.assertEquals(ScalingStats.EVENT.PROVISION, provisioner.getStats().toList().get(1).getEvent());
 
     provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
-    Assert.assertTrue(
+    Assertions.assertFalse(provisionedSomething);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
     DateTime anotherCreatedTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         createdTime.equals(anotherCreatedTime)
     );
 
@@ -604,19 +604,19 @@ public class PendingTaskBasedProvisioningStrategyTest
 
     // Expect to use capacity from workerCapacityHint config (which is 30)
     // and since there are two pending tasks, we will need one more worker
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertEquals(1, provisioner.getStats().toList().size());
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertEquals(1, provisioner.getStats().toList().size());
     DateTime createdTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertEquals(ScalingStats.EVENT.PROVISION, provisioner.getStats().toList().get(0).getEvent());
+    Assertions.assertEquals(ScalingStats.EVENT.PROVISION, provisioner.getStats().toList().get(0).getEvent());
 
     provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
-    Assert.assertTrue(
+    Assertions.assertFalse(provisionedSomething);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
     DateTime anotherCreatedTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         createdTime.equals(anotherCreatedTime)
     );
 
@@ -662,10 +662,10 @@ public class PendingTaskBasedProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
     DateTime createdTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
 
@@ -673,12 +673,12 @@ public class PendingTaskBasedProvisioningStrategyTest
 
     provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
-    Assert.assertTrue(
+    Assertions.assertFalse(provisionedSomething);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
     DateTime anotherCreatedTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         createdTime.equals(anotherCreatedTime)
     );
 
@@ -723,9 +723,9 @@ public class PendingTaskBasedProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertTrue(terminatedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
-    Assert.assertTrue(
+    Assertions.assertTrue(terminatedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.TERMINATE
     );
 
@@ -759,17 +759,17 @@ public class PendingTaskBasedProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertTrue(terminatedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
-    Assert.assertTrue(
+    Assertions.assertTrue(terminatedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.TERMINATE
     );
 
     terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertFalse(terminatedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
-    Assert.assertTrue(
+    Assertions.assertFalse(terminatedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.TERMINATE
     );
 
@@ -808,7 +808,7 @@ public class PendingTaskBasedProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertFalse(terminatedSomething);
+    Assertions.assertFalse(terminatedSomething);
     EasyMock.verify(autoScaler);
 
     EasyMock.reset(autoScaler);
@@ -820,7 +820,7 @@ public class PendingTaskBasedProvisioningStrategyTest
 
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
+    Assertions.assertFalse(provisionedSomething);
     EasyMock.verify(autoScaler);
     EasyMock.verify(runner);
   }
@@ -852,7 +852,7 @@ public class PendingTaskBasedProvisioningStrategyTest
 
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
-    Assert.assertFalse(terminatedSomething);
+    Assertions.assertFalse(terminatedSomething);
     EasyMock.verify(autoScaler);
 
     // Don't provision anything
@@ -863,7 +863,7 @@ public class PendingTaskBasedProvisioningStrategyTest
             .andReturn(Collections.singletonList("ip"));
     EasyMock.replay(autoScaler);
     boolean provisionedSomething = provisioner.doProvision();
-    Assert.assertFalse(provisionedSomething);
+    Assertions.assertFalse(provisionedSomething);
     EasyMock.verify(autoScaler);
 
     EasyMock.reset(autoScaler);
@@ -881,7 +881,7 @@ public class PendingTaskBasedProvisioningStrategyTest
     );
     EasyMock.replay(autoScaler);
     provisionedSomething = provisioner.doProvision();
-    Assert.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisionedSomething);
     EasyMock.verify(autoScaler);
     EasyMock.verify(runner);
   }
@@ -910,8 +910,8 @@ public class PendingTaskBasedProvisioningStrategyTest
 
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(terminatedSomething);
-    Assert.assertFalse(provisionedSomething);
+    Assertions.assertFalse(terminatedSomething);
+    Assertions.assertFalse(provisionedSomething);
 
     EasyMock.verify(autoScaler);
     EasyMock.verify(runner);
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/SimpleProvisioningStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/SimpleProvisioningStrategyTest.java
index 05b5f7ff165..084fab99a76 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/SimpleProvisioningStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/autoscaling/SimpleProvisioningStrategyTest.java
@@ -43,10 +43,10 @@ import org.apache.druid.java.util.emitter.service.ServiceEventBuilder;
 import org.easymock.EasyMock;
 import org.joda.time.DateTime;
 import org.joda.time.Period;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -67,7 +67,7 @@ public class SimpleProvisioningStrategyTest
   private AtomicReference<WorkerBehaviorConfig> workerConfig;
   private ScheduledExecutorService executorService = Execs.scheduledSingleThreaded("test service");
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     autoScaler = EasyMock.createMock(AutoScaler.class);
@@ -104,7 +104,7 @@ public class SimpleProvisioningStrategyTest
     );
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     executorService.shutdownNow();
@@ -138,9 +138,9 @@ public class SimpleProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
-    Assert.assertTrue(
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
 
@@ -176,21 +176,21 @@ public class SimpleProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
     DateTime createdTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
 
     provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
-    Assert.assertTrue(
+    Assertions.assertFalse(provisionedSomething);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
     DateTime anotherCreatedTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         createdTime.equals(anotherCreatedTime)
     );
 
@@ -234,10 +234,10 @@ public class SimpleProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertTrue(provisionedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
     DateTime createdTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
 
@@ -245,12 +245,12 @@ public class SimpleProvisioningStrategyTest
 
     provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
-    Assert.assertTrue(
+    Assertions.assertFalse(provisionedSomething);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.PROVISION
     );
     DateTime anotherCreatedTime = provisioner.getStats().toList().get(0).getTimestamp();
-    Assert.assertTrue(
+    Assertions.assertTrue(
         createdTime.equals(anotherCreatedTime)
     );
 
@@ -290,9 +290,9 @@ public class SimpleProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertTrue(terminatedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
-    Assert.assertTrue(
+    Assertions.assertTrue(terminatedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.TERMINATE
     );
 
@@ -331,17 +331,17 @@ public class SimpleProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertTrue(terminatedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
-    Assert.assertTrue(
+    Assertions.assertTrue(terminatedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.TERMINATE
     );
 
     terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertFalse(terminatedSomething);
-    Assert.assertTrue(provisioner.getStats().toList().size() == 1);
-    Assert.assertTrue(
+    Assertions.assertFalse(terminatedSomething);
+    Assertions.assertTrue(provisioner.getStats().toList().size() == 1);
+    Assertions.assertTrue(
         provisioner.getStats().toList().get(0).getEvent() == ScalingStats.EVENT.TERMINATE
     );
 
@@ -380,7 +380,7 @@ public class SimpleProvisioningStrategyTest
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
 
-    Assert.assertFalse(terminatedSomething);
+    Assertions.assertFalse(terminatedSomething);
     EasyMock.verify(autoScaler);
 
     EasyMock.reset(autoScaler);
@@ -392,7 +392,7 @@ public class SimpleProvisioningStrategyTest
 
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(provisionedSomething);
+    Assertions.assertFalse(provisionedSomething);
     EasyMock.verify(autoScaler);
     EasyMock.verify(runner);
   }
@@ -423,7 +423,7 @@ public class SimpleProvisioningStrategyTest
 
     Provisioner provisioner = strategy.makeProvisioner(runner);
     boolean terminatedSomething = provisioner.doTerminate();
-    Assert.assertFalse(terminatedSomething);
+    Assertions.assertFalse(terminatedSomething);
     EasyMock.verify(autoScaler);
 
     // Don't provision anything
@@ -434,7 +434,7 @@ public class SimpleProvisioningStrategyTest
             .andReturn(Collections.singletonList("ip"));
     EasyMock.replay(autoScaler);
     boolean provisionedSomething = provisioner.doProvision();
-    Assert.assertFalse(provisionedSomething);
+    Assertions.assertFalse(provisionedSomething);
     EasyMock.verify(autoScaler);
 
     EasyMock.reset(autoScaler);
@@ -452,7 +452,7 @@ public class SimpleProvisioningStrategyTest
     );
     EasyMock.replay(autoScaler);
     provisionedSomething = provisioner.doProvision();
-    Assert.assertTrue(provisionedSomething);
+    Assertions.assertTrue(provisionedSomething);
     EasyMock.verify(autoScaler);
     EasyMock.verify(runner);
   }
@@ -482,8 +482,8 @@ public class SimpleProvisioningStrategyTest
 
     boolean provisionedSomething = provisioner.doProvision();
 
-    Assert.assertFalse(terminatedSomething);
-    Assert.assertFalse(provisionedSomething);
+    Assertions.assertFalse(terminatedSomething);
+    Assertions.assertFalse(provisionedSomething);
 
     EasyMock.verify(autoScaler);
     EasyMock.verify(runner);
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/config/ForkingTaskRunnerConfigTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/config/ForkingTaskRunnerConfigTest.java
index 18845e770c0..c2fa0b0f51a 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/config/ForkingTaskRunnerConfigTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/config/ForkingTaskRunnerConfigTest.java
@@ -33,8 +33,8 @@ import org.apache.druid.guice.IndexingServiceModuleHelper;
 import org.apache.druid.guice.JsonConfigurator;
 import org.apache.druid.initialization.Initialization;
 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.util.List;
 import java.util.Properties;
@@ -67,15 +67,15 @@ public class ForkingTaskRunnerConfigTest
         "not found",
         ForkingTaskRunnerConfig.class
     );
-    Assert.assertEquals("", forkingTaskRunnerConfig.getJavaOpts());
-    Assert.assertEquals(ImmutableList.of(), forkingTaskRunnerConfig.getJavaOptsArray());
+    Assertions.assertEquals("", forkingTaskRunnerConfig.getJavaOpts());
+    Assertions.assertEquals(ImmutableList.of(), forkingTaskRunnerConfig.getJavaOptsArray());
   }
 
   @Test
   public void testSimpleStringJavaOpts()
   {
     final String javaOpts = "some string";
-    Assert.assertEquals(
+    Assertions.assertEquals(
         javaOpts,
         buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_PROPERTY, javaOpts).getJavaOpts()
     );
@@ -98,7 +98,7 @@ public class ForkingTaskRunnerConfigTest
                             + "            \"\\\"\\\"\",\n"
                             + "            \"AndMaybeEmptyQuotes\",\n"
                             + "            \"keep me around\"";
-    Assert.assertEquals(
+    Assertions.assertEquals(
         javaOpts,
         buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_PROPERTY, javaOpts).getJavaOpts()
     );
@@ -108,7 +108,7 @@ public class ForkingTaskRunnerConfigTest
   public void testSimpleJavaOptArray() throws JsonProcessingException
   {
     final List<String> javaOpts = ImmutableList.of("option1", "option \"2\"");
-    Assert.assertEquals(
+    Assertions.assertEquals(
         javaOpts,
         buildFromProperties(
             ForkingTaskRunnerConfig.JAVA_OPTS_ARRAY_PROPERTY,
@@ -136,7 +136,7 @@ public class ForkingTaskRunnerConfigTest
         "AndMaybeEmptyQuotes",
         "keep me around"
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         javaOpts,
         buildFromProperties(
             ForkingTaskRunnerConfig.JAVA_OPTS_ARRAY_PROPERTY,
@@ -149,7 +149,7 @@ public class ForkingTaskRunnerConfigTest
   public void testPorts() throws JsonProcessingException
   {
     final List<Integer> ports = ImmutableList.of(1024, 1025);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ports,
         buildFromProperties(
             IndexingServiceModuleHelper.INDEXER_RUNNER_PROPERTY_PREFIX + ".ports",
@@ -158,34 +158,49 @@ public class ForkingTaskRunnerConfigTest
     );
   }
 
-  @Test(expected = ProvisionException.class)
+  @Test
   public void testExceptionalPorts()
   {
-    buildFromProperties(IndexingServiceModuleHelper.INDEXER_RUNNER_PROPERTY_PREFIX + ".ports", "not an Integer");
+    Assertions.assertThrows(
+        ProvisionException.class,
+        () -> buildFromProperties(IndexingServiceModuleHelper.INDEXER_RUNNER_PROPERTY_PREFIX + ".ports", "not an Integer")
+    );
   }
 
-  @Test(expected = ProvisionException.class)
+  @Test
   public void testExceptionalPorts2()
   {
-    buildFromProperties(IndexingServiceModuleHelper.INDEXER_RUNNER_PROPERTY_PREFIX + ".ports", "1024"); // not an array
+    Assertions.assertThrows(
+        ProvisionException.class,
+        () -> buildFromProperties(IndexingServiceModuleHelper.INDEXER_RUNNER_PROPERTY_PREFIX + ".ports", "1024")
+    ); // not an array
   }
 
-  @Test(expected = ProvisionException.class)
+  @Test
   public void testExceptionalJavaOptArray()
   {
-    buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_ARRAY_PROPERTY, "not an array");
+    Assertions.assertThrows(
+        ProvisionException.class,
+        () -> buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_ARRAY_PROPERTY, "not an array")
+    );
   }
 
-  @Test(expected = ProvisionException.class)
+  @Test
   public void testExceptionalJavaOpt()
   {
-    buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_PROPERTY, "[\"not a string\"]");
+    Assertions.assertThrows(
+        ProvisionException.class,
+        () -> buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_PROPERTY, "[\"not a string\"]")
+    );
   }
 
-  @Test(expected = ProvisionException.class)
+  @Test
   public void testExceptionalJavaOpt2()
   {
-    buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_PROPERTY, "{\"not a string\":\"someVal\"}");
+    Assertions.assertThrows(
+        ProvisionException.class,
+        () -> buildFromProperties(ForkingTaskRunnerConfig.JAVA_OPTS_PROPERTY, "{\"not a string\":\"someVal\"}")
+    );
   }
 
   private ForkingTaskRunnerConfig buildFromProperties(String key, String value)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/KillUnreferencedIndexingStateTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/KillUnreferencedIndexingStateTest.java
index 7d8b022abd7..dae7bfeb1fe 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/KillUnreferencedIndexingStateTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/KillUnreferencedIndexingStateTest.java
@@ -32,18 +32,17 @@ import org.apache.druid.segment.metadata.SqlIndexingStateStorage;
 import org.apache.druid.timeline.CompactionState;
 import org.joda.time.DateTime;
 import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class KillUnreferencedIndexingStateTest
 {
-  @Rule
-  public final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule =
+  private final TestDerbyConnector.DerbyConnectorRule derbyConnectorRule =
       new TestDerbyConnector.DerbyConnectorRule();
 
   private final ObjectMapper jsonMapper = new DefaultObjectMapper();
@@ -52,9 +51,10 @@ public class KillUnreferencedIndexingStateTest
   private MetadataStorageTablesConfig tablesConfig;
   private SqlIndexingStateStorage compactionStateStorage;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
+    derbyConnectorRule.before();
     derbyConnector = derbyConnectorRule.getConnector();
     tablesConfig = derbyConnectorRule.metadataTablesConfigSupplier().get();
 
@@ -64,6 +64,12 @@ public class KillUnreferencedIndexingStateTest
     compactionStateStorage = new SqlIndexingStateStorage(tablesConfig, jsonMapper, derbyConnector);
   }
 
+  @AfterEach
+  public void tearDown()
+  {
+    derbyConnectorRule.after();
+  }
+
   @Test
   public void test_killUnreferencedCompactionState_validateLifecycleOfActiveCompactionState()
   {
@@ -93,19 +99,19 @@ public class KillUnreferencedIndexingStateTest
     compactionStateStorage.upsertIndexingState("test-ds", fingerprint, state, DateTimes.nowUtc());
     compactionStateStorage.markIndexingStatesAsActive(List.of(fingerprint));
 
-    Assert.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
 
     // Run 1: Should mark as unused (no segments reference it)
     duty.run();
-    Assert.assertEquals(Boolean.FALSE, getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertEquals(Boolean.FALSE, getCompactionStateUsedStatus(fingerprint));
 
     // Run 2: Still unused, but within retention period - should not delete
     duty.run();
-    Assert.assertNotNull(getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertNotNull(getCompactionStateUsedStatus(fingerprint));
 
     // Run 3: Past retention period - should delete
     duty.run();
-    Assert.assertNull(getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertNull(getCompactionStateUsedStatus(fingerprint));
   }
 
   @Test
@@ -135,9 +141,9 @@ public class KillUnreferencedIndexingStateTest
     compactionStateStorage.upsertIndexingState("test-ds", fingerprint, state, DateTimes.nowUtc());
     compactionStateStorage.markIndexingStatesAsActive(List.of(fingerprint));
 
-    Assert.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
     duty.run();
-    Assert.assertEquals(Boolean.FALSE, getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertEquals(Boolean.FALSE, getCompactionStateUsedStatus(fingerprint));
 
     // Now insert a used segment that references this fingerprint
     derbyConnector.retryWithHandle(handle -> {
@@ -165,7 +171,7 @@ public class KillUnreferencedIndexingStateTest
 
     // Confirm that the state is "repaired" now that it is referenced
     duty.run();
-    Assert.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
   }
 
   @Test
@@ -190,7 +196,7 @@ public class KillUnreferencedIndexingStateTest
     duty.run();
 
     // Should still be used (not marked as unused since cleanup is disabled)
-    Assert.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
+    Assertions.assertEquals(Boolean.TRUE, getCompactionStateUsedStatus(fingerprint));
   }
 
   @Test
@@ -217,13 +223,13 @@ public class KillUnreferencedIndexingStateTest
     CompactionState state = createTestCompactionState();
     compactionStateStorage.upsertIndexingState("test-ds", fingerprint, state, DateTimes.nowUtc());
 
-    Assert.assertEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(fingerprint));
+    Assertions.assertEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(fingerprint));
 
     duty.run();
-    Assert.assertNotNull(compactionStateStorage.isIndexingStatePending(fingerprint));
+    Assertions.assertNotNull(compactionStateStorage.isIndexingStatePending(fingerprint));
 
     duty.run();
-    Assert.assertNull(compactionStateStorage.isIndexingStatePending(fingerprint));
+    Assertions.assertNull(compactionStateStorage.isIndexingStatePending(fingerprint));
   }
 
   /**
@@ -257,16 +263,16 @@ public class KillUnreferencedIndexingStateTest
     compactionStateStorage.upsertIndexingState("test-ds", nonPendingFingerprint, state, DateTimes.nowUtc());
     compactionStateStorage.markIndexingStatesAsActive(List.of(nonPendingFingerprint));
 
-    Assert.assertEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(pendingFingerprint));
-    Assert.assertNotNull(getCompactionStateUsedStatus(nonPendingFingerprint));
+    Assertions.assertEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(pendingFingerprint));
+    Assertions.assertNotNull(getCompactionStateUsedStatus(nonPendingFingerprint));
 
     duty.run();
-    Assert.assertNotNull(compactionStateStorage.isIndexingStatePending(pendingFingerprint));
-    Assert.assertNull(getCompactionStateUsedStatus(nonPendingFingerprint));
+    Assertions.assertNotNull(compactionStateStorage.isIndexingStatePending(pendingFingerprint));
+    Assertions.assertNull(getCompactionStateUsedStatus(nonPendingFingerprint));
 
     duty.run();
-    Assert.assertNull(getCompactionStateUsedStatus(nonPendingFingerprint));
-    Assert.assertNull(compactionStateStorage.isIndexingStatePending(pendingFingerprint));
+    Assertions.assertNull(getCompactionStateUsedStatus(nonPendingFingerprint));
+    Assertions.assertNull(compactionStateStorage.isIndexingStatePending(pendingFingerprint));
   }
 
   @Test
@@ -291,7 +297,7 @@ public class KillUnreferencedIndexingStateTest
     CompactionState state = createTestCompactionState();
 
     compactionStateStorage.upsertIndexingState("test-ds", fingerprint, state, DateTimes.nowUtc());
-    Assert.assertEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(fingerprint));
+    Assertions.assertEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(fingerprint));
 
     // Now insert a used segment that references this fingerprint
     derbyConnector.retryWithHandle(handle -> {
@@ -318,10 +324,10 @@ public class KillUnreferencedIndexingStateTest
     });
 
     compactionStateStorage.markIndexingStatesAsActive(List.of(fingerprint));
-    Assert.assertNotEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(fingerprint));
+    Assertions.assertNotEquals(Boolean.TRUE, compactionStateStorage.isIndexingStatePending(fingerprint));
 
     duty.run();
-    Assert.assertNotNull(compactionStateStorage.isIndexingStatePending(fingerprint));
+    Assertions.assertNotNull(compactionStateStorage.isIndexingStatePending(fingerprint));
   }
 
   private Boolean getCompactionStateUsedStatus(String fingerprint)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/OverlordDutyExecutorTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/OverlordDutyExecutorTest.java
index 452ea66c5d9..ebe47c888cf 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/OverlordDutyExecutorTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/OverlordDutyExecutorTest.java
@@ -22,7 +22,7 @@ package org.apache.druid.indexing.overlord.duty;
 import com.google.common.collect.ImmutableSet;
 import org.apache.druid.java.util.common.concurrent.ScheduledExecutorFactory;
 import org.apache.druid.java.util.metrics.StubServiceEmitter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerConfigTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerConfigTest.java
index 1c78a98851e..a5a0bbbd92e 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerConfigTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerConfigTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.indexing.overlord.duty;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.druid.segment.TestHelper;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  */
@@ -49,10 +49,10 @@ public class TaskLogAutoCleanerConfigTest
         ), TaskLogAutoCleanerConfig.class
     );
 
-    Assert.assertTrue(config.isEnabled());
-    Assert.assertEquals(10, config.getInitialDelay());
-    Assert.assertEquals(40, config.getDelay());
-    Assert.assertEquals(30, config.getDurationToRetain());
+    Assertions.assertTrue(config.isEnabled());
+    Assertions.assertEquals(10, config.getInitialDelay());
+    Assertions.assertEquals(40, config.getDelay());
+    Assertions.assertEquals(30, config.getDurationToRetain());
   }
 
   @Test
@@ -71,9 +71,9 @@ public class TaskLogAutoCleanerConfigTest
         ), TaskLogAutoCleanerConfig.class
     );
 
-    Assert.assertFalse(config.isEnabled());
-    Assert.assertTrue(config.getInitialDelay() >= 60000 && config.getInitialDelay() <= 300000);
-    Assert.assertEquals(6 * 60 * 60 * 1000, config.getDelay());
-    Assert.assertEquals(Long.MAX_VALUE, config.getDurationToRetain());
+    Assertions.assertFalse(config.isEnabled());
+    Assertions.assertTrue(config.getInitialDelay() >= 60000 && config.getInitialDelay() <= 300000);
+    Assertions.assertEquals(6 * 60 * 60 * 1000, config.getDelay());
+    Assertions.assertEquals(Long.MAX_VALUE, config.getDurationToRetain());
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerTest.java
index edd9df957f1..c57a0375b36 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/TaskLogAutoCleanerTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.indexing.overlord.duty;
 
 import org.apache.druid.indexing.overlord.TaskStorage;
 import org.apache.druid.tasklogs.TaskLogKiller;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
 
@@ -61,11 +61,11 @@ public class TaskLogAutoCleanerTest
   {
     TaskLogAutoCleanerConfig cleanerConfig = new TaskLogAutoCleanerConfig(true, 2000L, 1000L, 60_000L);
     TaskLogAutoCleaner taskLogAutoCleaner = new TaskLogAutoCleaner(null, cleanerConfig, null);
-    Assert.assertTrue(taskLogAutoCleaner.isEnabled());
+    Assertions.assertTrue(taskLogAutoCleaner.isEnabled());
 
     final DutySchedule schedule = taskLogAutoCleaner.getSchedule();
-    Assert.assertEquals(cleanerConfig.getDelay(), schedule.getPeriodMillis());
-    Assert.assertEquals(cleanerConfig.getInitialDelay(), schedule.getInitialDelayMillis());
+    Assertions.assertEquals(cleanerConfig.getDelay(), schedule.getPeriodMillis());
+    Assertions.assertEquals(cleanerConfig.getInitialDelay(), schedule.getInitialDelayMillis());
   }
 
   @Test
@@ -73,7 +73,7 @@ public class TaskLogAutoCleanerTest
   {
     TaskLogAutoCleanerConfig cleanerConfig = new TaskLogAutoCleanerConfig(false, 2000L, 1000L, 60_000L);
     TaskLogAutoCleaner taskLogAutoCleaner = new TaskLogAutoCleaner(null, cleanerConfig, null);
-    Assert.assertFalse(taskLogAutoCleaner.isEnabled());
+    Assertions.assertFalse(taskLogAutoCleaner.isEnabled());
   }
 
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/UnusedSegmentsKillerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/UnusedSegmentsKillerTest.java
index bed08b4a85d..5ffe95bf159 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/UnusedSegmentsKillerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/duty/UnusedSegmentsKillerTest.java
@@ -48,10 +48,11 @@ import org.apache.druid.timeline.DataSegment;
 import org.joda.time.Duration;
 import org.joda.time.Interval;
 import org.joda.time.Period;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 import java.util.List;
 import java.util.Map;
@@ -60,8 +61,7 @@ import java.util.stream.Collectors;
 
 public class UnusedSegmentsKillerTest
 {
-  @Rule
-  public TaskActionTestKit taskActionTestKit = new TaskActionTestKit();
+  private final TaskActionTestKit taskActionTestKit = new TaskActionTestKit();
 
   private static final List<DataSegment> WIKI_SEGMENTS_1X10D =
       CreateDataSegments.ofDatasource(TestDataSource.WIKI)
@@ -76,9 +76,10 @@ public class UnusedSegmentsKillerTest
   private TestDataSegmentKiller dataSegmentKiller;
   private IndexerMetadataStorageCoordinator storageCoordinator;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
+    taskActionTestKit.before();
     emitter = taskActionTestKit.getServiceEmitter();
     leaderSelector = new TestDruidLeaderSelector();
     dataSegmentKiller = new TestDataSegmentKiller();
@@ -88,6 +89,12 @@ public class UnusedSegmentsKillerTest
     initKiller();
   }
 
+  @AfterEach
+  public void tearDown()
+  {
+    taskActionTestKit.after();
+  }
+
   private void initKiller()
   {
     killer = new UnusedSegmentsKiller(
@@ -123,8 +130,8 @@ public class UnusedSegmentsKillerTest
   public void test_getSchedule_returnsOneHourPeriod_ifEnabled()
   {
     final DutySchedule schedule = killer.getSchedule();
-    Assert.assertEquals(Duration.standardHours(1).getMillis(), schedule.getPeriodMillis());
-    Assert.assertEquals(Duration.standardMinutes(30).getMillis(), schedule.getInitialDelayMillis());
+    Assertions.assertEquals(Duration.standardHours(1).getMillis(), schedule.getPeriodMillis());
+    Assertions.assertEquals(Duration.standardMinutes(30).getMillis(), schedule.getInitialDelayMillis());
   }
 
   @Test
@@ -134,18 +141,18 @@ public class UnusedSegmentsKillerTest
     initKiller();
 
     final DutySchedule schedule = killer.getSchedule();
-    Assert.assertEquals(0, schedule.getPeriodMillis());
-    Assert.assertEquals(0, schedule.getInitialDelayMillis());
+    Assertions.assertEquals(0, schedule.getPeriodMillis());
+    Assertions.assertEquals(0, schedule.getInitialDelayMillis());
   }
 
   @Test
   public void test_run_startsProcessing_ifEnabled()
   {
-    Assert.assertFalse(killExecutor.hasPendingTasks());
-    Assert.assertTrue(killer.isEnabled());
+    Assertions.assertFalse(killExecutor.hasPendingTasks());
+    Assertions.assertTrue(killer.isEnabled());
 
     killer.run();
-    Assert.assertTrue(killExecutor.hasPendingTasks());
+    Assertions.assertTrue(killExecutor.hasPendingTasks());
   }
 
   @Test
@@ -154,10 +161,10 @@ public class UnusedSegmentsKillerTest
     killerConfig = new UnusedSegmentKillerConfig(false, null, null, null);
     initKiller();
 
-    Assert.assertFalse(killer.isEnabled());
+    Assertions.assertFalse(killer.isEnabled());
 
     killer.run();
-    Assert.assertFalse(killExecutor.hasPendingTasks());
+    Assertions.assertFalse(killExecutor.hasPendingTasks());
   }
 
   @Test
@@ -171,11 +178,11 @@ public class UnusedSegmentsKillerTest
 
     leaderSelector.stopBeingLeader();
 
-    Assert.assertTrue(killExecutor.hasPendingTasks());
+    Assertions.assertTrue(killExecutor.hasPendingTasks());
 
     finishQueuedKillJobs();
     emitter.verifyNotEmitted(UnusedSegmentsKiller.Metric.PROCESSED_KILL_JOBS);
-    Assert.assertFalse(killExecutor.hasPendingTasks());
+    Assertions.assertFalse(killExecutor.hasPendingTasks());
   }
 
   @Test
@@ -188,7 +195,7 @@ public class UnusedSegmentsKillerTest
 
     // Reset the queue and verify that kill jobs have been added to the queue
     killer.run();
-    Assert.assertTrue(killExecutor.hasPendingTasks());
+    Assertions.assertTrue(killExecutor.hasPendingTasks());
     emitter.verifyNotEmitted(UnusedSegmentsKiller.Metric.PROCESSED_KILL_JOBS);
 
     finishQueuedKillJobs();
@@ -203,7 +210,7 @@ public class UnusedSegmentsKillerTest
     emitter.verifyEmitted(TaskMetrics.SEGMENTS_DELETED_FROM_DEEPSTORE, 10);
     emitter.verifySum(TaskMetrics.SEGMENTS_DELETED_FROM_DEEPSTORE, 10L);
 
-    Assert.assertTrue(
+    Assertions.assertTrue(
         retrieveUnusedSegments(Intervals.ETERNITY).isEmpty()
     );
   }
@@ -224,7 +231,7 @@ public class UnusedSegmentsKillerTest
     storageCoordinator.commitSegments(Set.copyOf(segments), null);
     storageCoordinator.markAllSegmentsAsUnused(TestDataSource.WIKI);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         1000,
         retrieveUnusedSegments(Intervals.ETERNITY).size()
     );
@@ -237,7 +244,8 @@ public class UnusedSegmentsKillerTest
     emitter.verifySum(TaskMetrics.SEGMENTS_DELETED_FROM_DEEPSTORE, 700L);
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_maxSegmentsKilledByTask_is_10k()
   {
     leaderSelector.becomeLeader();
@@ -252,7 +260,7 @@ public class UnusedSegmentsKillerTest
     storageCoordinator.commitSegments(Set.copyOf(segments), null);
     storageCoordinator.markAllSegmentsAsUnused(TestDataSource.WIKI);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         12_000,
         retrieveUnusedSegments(Intervals.ETERNITY).size()
     );
@@ -270,14 +278,15 @@ public class UnusedSegmentsKillerTest
                                         .stream()
                                         .map(event -> event.getUserDims().get("taskId").toString())
                                         .toList();
-    Assert.assertEquals(2, taskIds.size());
+    Assertions.assertEquals(2, taskIds.size());
 
     // Verify that the tasks killed 10k and 2k segments respectively
     emitter.verifySum(TaskMetrics.SEGMENTS_DELETED_FROM_DEEPSTORE, Map.of("taskId", taskIds.get(0)), 10_000);
     emitter.verifySum(TaskMetrics.SEGMENTS_DELETED_FROM_DEEPSTORE, Map.of("taskId", taskIds.get(1)), 2_000);
   }
 
-  @Test(timeout = 20_000L)
+  @Timeout(20)
+  @Test
   public void test_maxIntervalsKilledInADatasource_is_10k()
   {
     leaderSelector.becomeLeader();
@@ -290,7 +299,7 @@ public class UnusedSegmentsKillerTest
     storageCoordinator.commitSegments(Set.copyOf(segments), null);
     storageCoordinator.markAllSegmentsAsUnused(TestDataSource.WIKI);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         10_001,
         retrieveUnusedSegments(Intervals.ETERNITY).size()
     );
@@ -341,7 +350,7 @@ public class UnusedSegmentsKillerTest
     emitter.verifyEmitted(UnusedSegmentsKiller.Metric.QUEUE_RESET_TIME, 1);
     emitter.verifyEmitted(UnusedSegmentsKiller.Metric.PROCESSED_KILL_JOBS, 5);
 
-    Assert.assertTrue(killExecutor.hasPendingTasks());
+    Assertions.assertTrue(killExecutor.hasPendingTasks());
 
     // Invoke run again and verify that queue has not been reset
     emitter.flush();
@@ -351,7 +360,7 @@ public class UnusedSegmentsKillerTest
     emitter.verifyEmitted(UnusedSegmentsKiller.Metric.PROCESSED_KILL_JOBS, 5);
 
     // All jobs have been processed
-    Assert.assertFalse(killExecutor.hasPendingTasks());
+    Assertions.assertFalse(killExecutor.hasPendingTasks());
   }
 
   @Test
@@ -374,14 +383,14 @@ public class UnusedSegmentsKillerTest
       return Intervals.of(splits[4] + "/" + splits[5]);
     }).collect(Collectors.toList());
 
-    Assert.assertEquals(10, killIntervals.size());
+    Assertions.assertEquals(10, killIntervals.size());
 
     final List<Interval> expectedIntervals =
         WIKI_SEGMENTS_1X10D.stream()
                            .map(DataSegment::getInterval)
                            .sorted(Comparators.intervalsByEndThenStart())
                            .collect(Collectors.toList());
-    Assert.assertEquals(expectedIntervals, killIntervals);
+    Assertions.assertEquals(expectedIntervals, killIntervals);
   }
 
   @Test
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java
index 931a192c753..b2c812a92cf 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/HttpRemoteTaskRunnerTest.java
@@ -73,9 +73,10 @@ import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
 import org.jboss.netty.handler.codec.http.HttpResponseStatus;
 import org.jboss.netty.handler.codec.http.HttpVersion;
 import org.joda.time.Period;
-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.junit.jupiter.api.Timeout;
 
 import java.io.InputStream;
 import java.util.ArrayList;
@@ -100,7 +101,7 @@ import static org.easymock.EasyMock.isA;
  */
 public class HttpRemoteTaskRunnerTest
 {
-  @Before
+  @BeforeEach
   public void setup()
   {
     EmittingLogger.registerEmitter(new NoopServiceEmitter());
@@ -110,7 +111,8 @@ public class HttpRemoteTaskRunnerTest
   Simulates startup of Overlord and Workers being discovered with no previously known tasks. Fresh tasks are given
   and expected to be completed.
    */
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testFreshStart() throws Exception
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -150,18 +152,19 @@ public class HttpRemoteTaskRunnerTest
     }
 
     for (Future<TaskStatus> future : futures) {
-      Assert.assertTrue(future.get().isSuccess());
+      Assertions.assertTrue(future.get().isSuccess());
     }
 
-    Assert.assertEquals(numTasks, taskRunner.getKnownTasks().size());
-    Assert.assertEquals(numTasks, taskRunner.getCompletedTasks().size());
-    Assert.assertEquals(4, taskRunner.getTotalCapacity());
-    Assert.assertTrue(taskRunner.getBlacklistedTaskSlotCount().isEmpty());
-    Assert.assertEquals(-1, taskRunner.getMaximumCapacityWithAutoscale());
-    Assert.assertEquals(0, taskRunner.getUsedCapacity());
+    Assertions.assertEquals(numTasks, taskRunner.getKnownTasks().size());
+    Assertions.assertEquals(numTasks, taskRunner.getCompletedTasks().size());
+    Assertions.assertEquals(4, taskRunner.getTotalCapacity());
+    Assertions.assertTrue(taskRunner.getBlacklistedTaskSlotCount().isEmpty());
+    Assertions.assertEquals(-1, taskRunner.getMaximumCapacityWithAutoscale());
+    Assertions.assertEquals(0, taskRunner.getUsedCapacity());
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testFreshStart_nodeDiscoveryTimedOut() throws Exception
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery(true);
@@ -201,19 +204,20 @@ public class HttpRemoteTaskRunnerTest
     }
 
     for (Future<TaskStatus> future : futures) {
-      Assert.assertTrue(future.get().isSuccess());
+      Assertions.assertTrue(future.get().isSuccess());
     }
 
-    Assert.assertEquals(numTasks, taskRunner.getKnownTasks().size());
-    Assert.assertEquals(numTasks, taskRunner.getCompletedTasks().size());
-    Assert.assertEquals(4, taskRunner.getTotalCapacity());
-    Assert.assertEquals(0, taskRunner.getUsedCapacity());
+    Assertions.assertEquals(numTasks, taskRunner.getKnownTasks().size());
+    Assertions.assertEquals(numTasks, taskRunner.getCompletedTasks().size());
+    Assertions.assertEquals(4, taskRunner.getTotalCapacity());
+    Assertions.assertEquals(0, taskRunner.getUsedCapacity());
   }
 
   /*
   Simulates startup of Overlord. Overlord is then stopped and is expected to close down certain things.
    */
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testFreshStartAndStop()
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -251,13 +255,13 @@ public class HttpRemoteTaskRunnerTest
     taskRunner.start();
     druidNodeDiscovery.getListeners().get(0).nodesAdded(ImmutableList.of(druidNode1, druidNode2));
     ConcurrentMap<String, WorkerHolder> workers = taskRunner.getWorkersForTestingReadOnly();
-    Assert.assertEquals(2, workers.size());
-    Assert.assertTrue(workers.values().stream().noneMatch(w -> w.getUnderlyingSyncer().isExecutorShutdown()));
+    Assertions.assertEquals(2, workers.size());
+    Assertions.assertTrue(workers.values().stream().noneMatch(w -> w.getUnderlyingSyncer().isExecutorShutdown()));
     workers.values().iterator().next().stop();
     taskRunner.stop();
-    Assert.assertTrue(druidNodeDiscovery.getListeners().isEmpty());
-    Assert.assertEquals(2, workers.size());
-    Assert.assertTrue(workers.values().stream().allMatch(w -> w.getUnderlyingSyncer().isExecutorShutdown()));
+    Assertions.assertTrue(druidNodeDiscovery.getListeners().isEmpty());
+    Assertions.assertEquals(2, workers.size());
+    Assertions.assertTrue(workers.values().stream().allMatch(w -> w.getUnderlyingSyncer().isExecutorShutdown()));
     EasyMock.verify(druidNodeDiscoveryProvider, provisioningStrategy, provisioningService);
   }
 
@@ -265,7 +269,8 @@ public class HttpRemoteTaskRunnerTest
   Simulates startup of Overlord with no provisoner. Overlord is then stopped and is expected to close down certain
   things.
    */
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testFreshStartAndStopNoProvisioner()
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -333,7 +338,8 @@ public class HttpRemoteTaskRunnerTest
   Simulates one task not getting acknowledged to be running after assigning it to a worker. But, other tasks are
   successfully assigned to other worker and get completed.
    */
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testOneStuckTaskAssignmentDoesntBlockOthers() throws Exception
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -415,16 +421,17 @@ public class HttpRemoteTaskRunnerTest
     Future<TaskStatus> future2 = taskRunner.run(task2);
     Future<TaskStatus> future3 = taskRunner.run(task3);
 
-    Assert.assertTrue(future2.get().isSuccess());
-    Assert.assertTrue(future3.get().isSuccess());
+    Assertions.assertTrue(future2.get().isSuccess());
+    Assertions.assertTrue(future3.get().isSuccess());
 
-    Assert.assertEquals(task1.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
+    Assertions.assertEquals(task1.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
   }
 
   /*
   Simulates restart of the Overlord where taskRunner, on start, discovers workers with prexisting tasks.
    */
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testTaskRunnerRestart() throws Exception
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -567,19 +574,20 @@ public class HttpRemoteTaskRunnerTest
 
     EasyMock.verify(taskStorageMock);
 
-    Assert.assertEquals(ImmutableSet.of(task2.getId(), task5.getId()), taskShutdowns);
-    Assert.assertTrue(taskRunner.getPendingTasks().isEmpty());
+    Assertions.assertEquals(ImmutableSet.of(task2.getId(), task5.getId()), taskShutdowns);
+    Assertions.assertTrue(taskRunner.getPendingTasks().isEmpty());
 
     TaskRunnerWorkItem item = Iterables.getOnlyElement(taskRunner.getRunningTasks());
-    Assert.assertEquals(task4.getId(), item.getTaskId());
+    Assertions.assertEquals(task4.getId(), item.getTaskId());
 
-    Assert.assertTrue(taskRunner.run(task3).get().isSuccess());
+    Assertions.assertTrue(taskRunner.run(task3).get().isSuccess());
 
-    Assert.assertEquals(2, taskRunner.getKnownTasks().size());
+    Assertions.assertEquals(2, taskRunner.getKnownTasks().size());
 
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testWorkerDisapperAndReappearBeforeItsCleanup() throws Exception
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -749,11 +757,12 @@ public class HttpRemoteTaskRunnerTest
         )
     );
 
-    Assert.assertTrue(future1.get().isSuccess());
-    Assert.assertTrue(future2.get().isSuccess());
+    Assertions.assertTrue(future1.get().isSuccess());
+    Assertions.assertTrue(future2.get().isSuccess());
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testWorkerDisapperAndReappearAfterItsCleanup() throws Exception
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -884,16 +893,16 @@ public class HttpRemoteTaskRunnerTest
         )
     );
 
-    Assert.assertTrue(future1.get().isFailure());
-    Assert.assertTrue(future2.get().isFailure());
-    Assert.assertNotNull(future1.get().getErrorMsg());
-    Assert.assertNotNull(future2.get().getErrorMsg());
-    Assert.assertTrue(
+    Assertions.assertTrue(future1.get().isFailure());
+    Assertions.assertTrue(future2.get().isFailure());
+    Assertions.assertNotNull(future1.get().getErrorMsg());
+    Assertions.assertNotNull(future2.get().getErrorMsg());
+    Assertions.assertTrue(
         future1.get().getErrorMsg().startsWith(
             "The worker that this task was assigned disappeared and did not report cleanup within timeout"
         )
     );
-    Assert.assertTrue(
+    Assertions.assertTrue(
         future2.get().getErrorMsg().startsWith(
             "The worker that this task was assigned disappeared and did not report cleanup within timeout"
         )
@@ -940,12 +949,13 @@ public class HttpRemoteTaskRunnerTest
       Thread.sleep(100);
     }
 
-    Assert.assertEquals(ImmutableSet.of(task2.getId()), actualShutdowns);
-    Assert.assertTrue(taskRunner.run(task1).get().isFailure());
-    Assert.assertTrue(taskRunner.run(task2).get().isFailure());
+    Assertions.assertEquals(ImmutableSet.of(task2.getId()), actualShutdowns);
+    Assertions.assertTrue(taskRunner.run(task1).get().isFailure());
+    Assertions.assertTrue(taskRunner.run(task2).get().isFailure());
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testMarkWorkersLazy() throws Exception
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -1007,9 +1017,9 @@ public class HttpRemoteTaskRunnerTest
 
     taskRunner.start();
 
-    Assert.assertTrue(taskRunner.getTotalTaskSlotCount().isEmpty());
-    Assert.assertTrue(taskRunner.getIdleTaskSlotCount().isEmpty());
-    Assert.assertTrue(taskRunner.getUsedTaskSlotCount().isEmpty());
+    Assertions.assertTrue(taskRunner.getTotalTaskSlotCount().isEmpty());
+    Assertions.assertTrue(taskRunner.getIdleTaskSlotCount().isEmpty());
+    Assertions.assertTrue(taskRunner.getUsedTaskSlotCount().isEmpty());
 
     AtomicInteger ticks = new AtomicInteger();
 
@@ -1053,9 +1063,9 @@ public class HttpRemoteTaskRunnerTest
 
     druidNodeDiscovery.getListeners().get(0).nodesAdded(ImmutableList.of(druidNode1));
 
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(1, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
 
     taskRunner.run(task1);
 
@@ -1063,9 +1073,9 @@ public class HttpRemoteTaskRunnerTest
       Thread.sleep(100);
     }
 
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
 
     DiscoveryDruidNode druidNode2 = new DiscoveryDruidNode(
         new DruidNode("service", "host2", false, 8080, null, true, false),
@@ -1095,12 +1105,12 @@ public class HttpRemoteTaskRunnerTest
 
     druidNodeDiscovery.getListeners().get(0).nodesAdded(ImmutableList.of(druidNode2));
 
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
-    Assert.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(1, taskRunner.getIdleTaskSlotCount().get(additionalWorkerCategory).longValue());
-    Assert.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getIdleTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
 
     taskRunner.run(task2);
 
@@ -1108,12 +1118,12 @@ public class HttpRemoteTaskRunnerTest
       Thread.sleep(100);
     }
 
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
-    Assert.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertFalse(taskRunner.getIdleTaskSlotCount().containsKey(additionalWorkerCategory));
-    Assert.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertFalse(taskRunner.getIdleTaskSlotCount().containsKey(additionalWorkerCategory));
+    Assertions.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
 
     DiscoveryDruidNode druidNode3 = new DiscoveryDruidNode(
         new DruidNode("service", "host3", false, 8080, null, true, false),
@@ -1143,52 +1153,54 @@ public class HttpRemoteTaskRunnerTest
 
     druidNodeDiscovery.getListeners().get(0).nodesAdded(ImmutableList.of(druidNode3));
 
-    Assert.assertEquals(2, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
-    Assert.assertEquals(1, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertFalse(taskRunner.getIdleTaskSlotCount().containsKey(additionalWorkerCategory));
-    Assert.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
-    Assert.assertFalse(taskRunner.getLazyTaskSlotCount().containsKey(WorkerConfig.DEFAULT_CATEGORY));
-    Assert.assertFalse(taskRunner.getLazyTaskSlotCount().containsKey(additionalWorkerCategory));
+    Assertions.assertEquals(2, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(1, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertFalse(taskRunner.getIdleTaskSlotCount().containsKey(additionalWorkerCategory));
+    Assertions.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertFalse(taskRunner.getLazyTaskSlotCount().containsKey(WorkerConfig.DEFAULT_CATEGORY));
+    Assertions.assertFalse(taskRunner.getLazyTaskSlotCount().containsKey(additionalWorkerCategory));
 
-    Assert.assertEquals(task1.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
-    Assert.assertEquals(task2.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
+    Assertions.assertEquals(task1.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
+    Assertions.assertEquals(task2.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         Collections.emptyList(),
         taskRunner.markWorkersLazy(Predicates.alwaysTrue(), 0)
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "host3:8080",
         Iterables.getOnlyElement(taskRunner.markWorkersLazy(Predicates.alwaysTrue(), 1))
                  .getHost()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "host3:8080",
         Iterables.getOnlyElement(taskRunner.markWorkersLazy(Predicates.alwaysTrue(), Integer.MAX_VALUE))
                  .getHost()
     );
 
-    Assert.assertEquals(2, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
-    Assert.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertFalse(taskRunner.getIdleTaskSlotCount().containsKey(additionalWorkerCategory));
-    Assert.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
-    Assert.assertEquals(1, taskRunner.getLazyTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
-    Assert.assertFalse(taskRunner.getLazyTaskSlotCount().containsKey(additionalWorkerCategory));
+    Assertions.assertEquals(2, taskRunner.getTotalTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(1, taskRunner.getTotalTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(0, taskRunner.getIdleTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertFalse(taskRunner.getIdleTaskSlotCount().containsKey(additionalWorkerCategory));
+    Assertions.assertEquals(1, taskRunner.getUsedTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertEquals(0, taskRunner.getUsedTaskSlotCount().get(additionalWorkerCategory).longValue());
+    Assertions.assertEquals(1, taskRunner.getLazyTaskSlotCount().get(WorkerConfig.DEFAULT_CATEGORY).longValue());
+    Assertions.assertFalse(taskRunner.getLazyTaskSlotCount().containsKey(additionalWorkerCategory));
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testStreamTaskReportsFromWorker() throws Exception
   {
     assertStreamTaskReportsFromWorker(HttpResponseStatus.OK, Optional.of("my report!"));
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testStreamTaskReportsUnavailableFromWorker() throws Exception
   {
     assertStreamTaskReportsFromWorker(HttpResponseStatus.SERVICE_UNAVAILABLE, Optional.absent());
@@ -1215,7 +1227,7 @@ public class HttpRemoteTaskRunnerTest
     EasyMock.replay(workerHolder);
 
     Future<TaskStatus> future = taskRunner.run(task);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
 
     // RUNNING notification from worker
     taskRunner.taskAddedOrUpdated(TaskAnnouncement.create(
@@ -1223,7 +1235,7 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.running(task.getId()),
         TaskLocation.create("worker", 1000, 1001)
     ), workerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
 
     // Another RUNNING notification from worker, notifying change in location
     taskRunner.taskAddedOrUpdated(TaskAnnouncement.create(
@@ -1231,7 +1243,7 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.running(task.getId()),
         TaskLocation.create("worker", 1, 2)
     ), workerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
 
     // Redundant RUNNING notification from worker, ignored
     taskRunner.taskAddedOrUpdated(TaskAnnouncement.create(
@@ -1239,7 +1251,7 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.running(task.getId()),
         TaskLocation.create("worker", 1, 2)
     ), workerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
 
     // Another "rogue-worker" reports running it, and gets asked to shutdown the task
     WorkerHolder rogueWorkerHolder = EasyMock.createMock(WorkerHolder.class);
@@ -1253,7 +1265,7 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.running(task.getId()),
         TaskLocation.create("rogue-worker", 1, 2)
     ), rogueWorkerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
     EasyMock.verify(rogueWorkerHolder);
 
     // "rogue-worker" reports FAILURE for the task, ignored
@@ -1267,7 +1279,7 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.failure(task.getId(), "Dummy task status failure err message"),
         TaskLocation.create("rogue-worker", 1, 2)
     ), rogueWorkerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getRunningTasks()).getTaskId());
     EasyMock.verify(rogueWorkerHolder);
 
     // workers sends SUCCESS notification, task is marked SUCCESS now.
@@ -1276,8 +1288,8 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.success(task.getId()),
         TaskLocation.create("worker", 1, 2)
     ), workerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
-    Assert.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
+    Assertions.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
 
     // "rogue-worker" reports running it, and gets asked to shutdown the task
     rogueWorkerHolder = EasyMock.createMock(WorkerHolder.class);
@@ -1291,7 +1303,7 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.running(task.getId()),
         TaskLocation.create("rogue-worker", 1, 2)
     ), rogueWorkerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
     EasyMock.verify(rogueWorkerHolder);
 
     // "rogue-worker" reports FAILURE for the tasks, ignored
@@ -1305,14 +1317,14 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.failure(task.getId(), "Dummy task status failure for testing"),
         TaskLocation.create("rogue-worker", 1, 2)
     ), rogueWorkerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
     EasyMock.verify(rogueWorkerHolder);
 
-    Assert.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
+    Assertions.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
 
     EasyMock.verify(workerHolder);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         listenerNotificationsAccumulator,
         ImmutableList.of(
             ImmutableList.of(task.getId(), TaskLocation.create("worker", 1000, 1001)),
@@ -1346,20 +1358,20 @@ public class HttpRemoteTaskRunnerTest
     EasyMock.replay(workerHolder);
 
     Future<TaskStatus> future = taskRunner.run(task);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getPendingTasks()).getTaskId());
 
     taskRunner.taskAddedOrUpdated(TaskAnnouncement.create(
         task,
         TaskStatus.success(task.getId()),
         TaskLocation.create("worker", 1, 2)
     ), workerHolder);
-    Assert.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
+    Assertions.assertEquals(task.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
 
-    Assert.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
+    Assertions.assertEquals(TaskState.SUCCESS, future.get().getStatusCode());
 
     EasyMock.verify(workerHolder);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         listenerNotificationsAccumulator,
         ImmutableList.of(
             ImmutableList.of(task.getId(), TaskLocation.create("worker", 1, 2)),
@@ -1406,7 +1418,7 @@ public class HttpRemoteTaskRunnerTest
     workerHolder.shutdownTask(task5.getId());
     EasyMock.replay(workerHolder);
 
-    Assert.assertEquals(0, taskRunner.getKnownTasks().size());
+    Assertions.assertEquals(0, taskRunner.getKnownTasks().size());
 
     taskRunner.taskAddedOrUpdated(TaskAnnouncement.create(
         task1,
@@ -1446,7 +1458,7 @@ public class HttpRemoteTaskRunnerTest
 
     EasyMock.verify(workerHolder, taskStorage);
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         listenerNotificationsAccumulator,
         ImmutableList.of(
             ImmutableList.of(task1.getId(), TaskLocation.create("worker", 1, 2)),
@@ -1560,9 +1572,9 @@ public class HttpRemoteTaskRunnerTest
     druidNodeDiscovery.getListeners().get(0).nodesAdded(ImmutableList.of(druidNode1));
 
     Future<TaskStatus> future = taskRunner.run(NoopTask.create());
-    Assert.assertTrue(future.get().isFailure());
-    Assert.assertNotNull(future.get().getErrorMsg());
-    Assert.assertTrue(
+    Assertions.assertTrue(future.get().isFailure());
+    Assertions.assertNotNull(future.get().getErrorMsg());
+    Assertions.assertTrue(
         future.get().getErrorMsg().startsWith("The worker that this task is assigned did not start it in timeout")
     );
   }
@@ -1670,11 +1682,11 @@ public class HttpRemoteTaskRunnerTest
     druidNodeDiscovery.getListeners().get(0).nodesAdded(ImmutableList.of(druidNode1));
 
     Future<TaskStatus> future = taskRunner.run(NoopTask.create());
-    Assert.assertTrue(future.get().isFailure());
-    Assert.assertNotNull(future.get().getErrorMsg());
-    Assert.assertTrue(
-        StringUtils.format("Actual message is: %s", future.get().getErrorMsg()),
-        future.get().getErrorMsg().startsWith("Failed to assign this task")
+    Assertions.assertTrue(future.get().isFailure());
+    Assertions.assertNotNull(future.get().getErrorMsg());
+    Assertions.assertTrue(
+        future.get().getErrorMsg().startsWith("Failed to assign this task"),
+        StringUtils.format("Actual message is: %s", future.get().getErrorMsg())
     );
   }
 
@@ -1706,7 +1718,7 @@ public class HttpRemoteTaskRunnerTest
     taskRunner.run(pendingTask);
     // Pending task is not cleaned up immediately
     taskRunner.shutdown(pendingTask.getId(), "Forced shutdown");
-    Assert.assertTrue(taskRunner.getKnownTasks()
+    Assertions.assertTrue(taskRunner.getKnownTasks()
                                 .stream()
                                 .map(TaskRunnerWorkItem::getTaskId)
                                 .collect(Collectors.toSet())
@@ -1720,7 +1732,7 @@ public class HttpRemoteTaskRunnerTest
         TaskStatus.success(completedTask.getId()),
         TaskLocation.create("worker", 1, 2)
     ), workerHolder);
-    Assert.assertEquals(completedTask.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
+    Assertions.assertEquals(completedTask.getId(), Iterables.getOnlyElement(taskRunner.getCompletedTasks()).getTaskId());
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
     DruidNodeDiscoveryProvider druidNodeDiscoveryProvider = EasyMock.createMock(DruidNodeDiscoveryProvider.class);
     EasyMock.expect(druidNodeDiscoveryProvider.getForService(WorkerNodeService.DISCOVERY_SERVICE_KEY))
@@ -1730,7 +1742,7 @@ public class HttpRemoteTaskRunnerTest
 
     // Completed tasks are cleaned up when shutdown is invokded on them (by TaskQueue)
     taskRunner.shutdown(completedTask.getId(), "Cleanup");
-    Assert.assertFalse(taskRunner.getKnownTasks()
+    Assertions.assertFalse(taskRunner.getKnownTasks()
                                 .stream()
                                 .map(TaskRunnerWorkItem::getTaskId)
                                 .collect(Collectors.toSet())
@@ -1739,7 +1751,8 @@ public class HttpRemoteTaskRunnerTest
 
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testSyncMonitoring_finiteIteration()
   {
     TestDruidNodeDiscovery druidNodeDiscovery = new TestDruidNodeDiscovery();
@@ -1778,9 +1791,9 @@ public class HttpRemoteTaskRunnerTest
     taskRunner.addWorker(createWorker("abc"));
     taskRunner.addWorker(createWorker("xyz"));
     taskRunner.addWorker(createWorker("lol"));
-    Assert.assertEquals(3, taskRunner.getWorkerSyncerDebugInfo().size());
+    Assertions.assertEquals(3, taskRunner.getWorkerSyncerDebugInfo().size());
     taskRunner.syncMonitoring();
-    Assert.assertEquals(3, taskRunner.getWorkerSyncerDebugInfo().size());
+    Assertions.assertEquals(3, taskRunner.getWorkerSyncerDebugInfo().size());
   }
 
   @Test
@@ -1802,7 +1815,7 @@ public class HttpRemoteTaskRunnerTest
         EasyMock.createMock(TaskStorage.class),
         new NoopServiceEmitter()
     );
-    Assert.assertEquals(-1, taskRunner.getMaximumCapacityWithAutoscale());
+    Assertions.assertEquals(-1, taskRunner.getMaximumCapacityWithAutoscale());
   }
 
   @Test
@@ -1824,7 +1837,7 @@ public class HttpRemoteTaskRunnerTest
         EasyMock.createMock(TaskStorage.class),
         new NoopServiceEmitter()
     );
-    Assert.assertEquals(-1, taskRunner.getMaximumCapacityWithAutoscale());
+    Assertions.assertEquals(-1, taskRunner.getMaximumCapacityWithAutoscale());
   }
 
   @Test
@@ -1847,7 +1860,7 @@ public class HttpRemoteTaskRunnerTest
         new NoopServiceEmitter()
     );
     // Default autoscaler has max workers of 0
-    Assert.assertEquals(0, taskRunner.getMaximumCapacityWithAutoscale());
+    Assertions.assertEquals(0, taskRunner.getMaximumCapacityWithAutoscale());
   }
 
   public static HttpRemoteTaskRunner createTaskRunnerForTestTaskAddedOrUpdated(
@@ -1992,7 +2005,7 @@ public class HttpRemoteTaskRunnerTest
       );
       taskRunner.run(task);
 
-      Assert.assertTrue(
+      Assertions.assertTrue(
           TestUtils.conditionValid(
               () ->
                   !taskRunner.getRunningTasks().isEmpty()
@@ -2004,13 +2017,13 @@ public class HttpRemoteTaskRunnerTest
 
       final Optional<InputStream> stream = taskRunner.streamTaskReports(task.getId());
       if (expectedReport.isPresent()) {
-        Assert.assertTrue(stream.isPresent());
-        Assert.assertEquals(expectedReport.get(), StringUtils.fromUtf8(ByteStreams.toByteArray(stream.get())));
+        Assertions.assertTrue(stream.isPresent());
+        Assertions.assertEquals(expectedReport.get(), StringUtils.fromUtf8(ByteStreams.toByteArray(stream.get())));
       } else {
-        Assert.assertEquals(Optional.absent(), stream);
+        Assertions.assertEquals(Optional.absent(), stream);
       }
 
-      Assert.assertEquals(
+      Assertions.assertEquals(
           "http://host:1234/druid/worker/v1/chat/task%20id%20with%20spaces/liveReports",
           capturedRequest.getValue().getUrl().toString()
       );
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolderTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolderTest.java
index 7bd3be3e535..c64a0cb1810 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolderTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/hrtr/WorkerHolderTest.java
@@ -33,8 +33,8 @@ import org.apache.druid.java.util.http.client.HttpClient;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.server.coordination.ChangeRequestHttpSyncer;
 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.ArrayList;
 import java.util.List;
@@ -90,8 +90,8 @@ public class WorkerHolderTest
 
     ChangeRequestHttpSyncer.Listener<WorkerHistoryItem> syncListener = workerHolder.createSyncListener();
 
-    Assert.assertFalse(workerHolder.isEnabled());
-    Assert.assertFalse(workerHolder.isInitialized());
+    Assertions.assertFalse(workerHolder.isEnabled());
+    Assertions.assertFalse(workerHolder.isInitialized());
 
     syncListener.fullSync(
         ImmutableList.of(
@@ -114,23 +114,23 @@ public class WorkerHolderTest
         )
     );
 
-    Assert.assertTrue(workerHolder.isEnabled());
+    Assertions.assertTrue(workerHolder.isEnabled());
 
-    Assert.assertEquals(4, updates.size());
+    Assertions.assertEquals(4, updates.size());
 
-    Assert.assertEquals(task1.getId(), updates.get(0).getTaskId());
-    Assert.assertTrue(updates.get(0).getTaskStatus().isSuccess());
+    Assertions.assertEquals(task1.getId(), updates.get(0).getTaskId());
+    Assertions.assertTrue(updates.get(0).getTaskStatus().isSuccess());
 
-    Assert.assertEquals(task2.getId(), updates.get(1).getTaskId());
-    Assert.assertTrue(updates.get(1).getTaskStatus().isRunnable());
+    Assertions.assertEquals(task2.getId(), updates.get(1).getTaskId());
+    Assertions.assertTrue(updates.get(1).getTaskStatus().isRunnable());
 
-    Assert.assertEquals(task3.getId(), updates.get(2).getTaskId());
-    Assert.assertTrue(updates.get(2).getTaskStatus().isRunnable());
+    Assertions.assertEquals(task3.getId(), updates.get(2).getTaskId());
+    Assertions.assertTrue(updates.get(2).getTaskStatus().isRunnable());
 
-    Assert.assertEquals(task0.getId(), updates.get(3).getTaskId());
-    Assert.assertTrue(updates.get(3).getTaskStatus().isFailure());
-    Assert.assertNotNull(updates.get(3).getTaskStatus().getErrorMsg());
-    Assert.assertTrue(
+    Assertions.assertEquals(task0.getId(), updates.get(3).getTaskId());
+    Assertions.assertTrue(updates.get(3).getTaskStatus().isFailure());
+    Assertions.assertNotNull(updates.get(3).getTaskStatus().getErrorMsg());
+    Assertions.assertTrue(
         updates.get(3).getTaskStatus().getErrorMsg().startsWith(
             "This task disappeared on the worker where it was assigned"
         )
@@ -153,20 +153,20 @@ public class WorkerHolderTest
         )
     );
 
-    Assert.assertTrue(workerHolder.isEnabled());
-    Assert.assertEquals(2, updates.size());
+    Assertions.assertTrue(workerHolder.isEnabled());
+    Assertions.assertEquals(2, updates.size());
 
-    Assert.assertEquals(task2.getId(), updates.get(0).getTaskId());
-    Assert.assertTrue(updates.get(0).getTaskStatus().isFailure());
-    Assert.assertNotNull(updates.get(0).getTaskStatus().getErrorMsg());
-    Assert.assertTrue(
+    Assertions.assertEquals(task2.getId(), updates.get(0).getTaskId());
+    Assertions.assertTrue(updates.get(0).getTaskStatus().isFailure());
+    Assertions.assertNotNull(updates.get(0).getTaskStatus().getErrorMsg());
+    Assertions.assertTrue(
         updates.get(0).getTaskStatus().getErrorMsg().startsWith(
             "This task disappeared on the worker where it was assigned"
         )
     );
 
-    Assert.assertEquals(task3.getId(), updates.get(1).getTaskId());
-    Assert.assertTrue(updates.get(1).getTaskStatus().isRunnable());
+    Assertions.assertEquals(task3.getId(), updates.get(1).getTaskId());
+    Assertions.assertTrue(updates.get(1).getTaskStatus().isRunnable());
 
     updates.clear();
 
@@ -191,18 +191,18 @@ public class WorkerHolderTest
         )
     );
 
-    Assert.assertFalse(workerHolder.isEnabled());
+    Assertions.assertFalse(workerHolder.isEnabled());
 
-    Assert.assertEquals(3, updates.size());
+    Assertions.assertEquals(3, updates.size());
 
-    Assert.assertEquals(task1.getId(), updates.get(0).getTaskId());
-    Assert.assertTrue(updates.get(0).getTaskStatus().isSuccess());
+    Assertions.assertEquals(task1.getId(), updates.get(0).getTaskId());
+    Assertions.assertTrue(updates.get(0).getTaskStatus().isSuccess());
 
-    Assert.assertEquals(task2.getId(), updates.get(1).getTaskId());
-    Assert.assertTrue(updates.get(1).getTaskStatus().isRunnable());
+    Assertions.assertEquals(task2.getId(), updates.get(1).getTaskId());
+    Assertions.assertTrue(updates.get(1).getTaskStatus().isRunnable());
 
-    Assert.assertEquals(task3.getId(), updates.get(2).getTaskId());
-    Assert.assertTrue(updates.get(2).getTaskStatus().isRunnable());
+    Assertions.assertEquals(task3.getId(), updates.get(2).getTaskId());
+    Assertions.assertTrue(updates.get(2).getTaskStatus().isRunnable());
 
     updates.clear();
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java
index 53a5d05f3f1..fc51a8e63a8 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordCompactionResourceTest.java
@@ -23,7 +23,7 @@ import com.google.common.base.Optional;
 import com.google.common.util.concurrent.Futures;
 import org.apache.druid.audit.AuditManager;
 import org.apache.druid.client.coordinator.CoordinatorClient;
-import org.apache.druid.error.DruidExceptionMatcher;
+import org.apache.druid.error.DruidException;
 import org.apache.druid.error.ErrorResponse;
 import org.apache.druid.indexer.CompactionEngine;
 import org.apache.druid.indexing.compact.CompactionScheduler;
@@ -49,12 +49,11 @@ import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.server.security.AuthenticationResult;
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.easymock.EasyMock;
-import org.hamcrest.MatcherAssert;
 import org.joda.time.Period;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.core.Response;
@@ -88,7 +87,7 @@ public class OverlordCompactionResourceTest
    */
   private CompactionScheduler validator;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     useSupervisors.set(true);
@@ -130,7 +129,7 @@ public class OverlordCompactionResourceTest
     EasyMock.replay(validator, taskMaster, authorizerMapper);
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     EasyMock.verify(
@@ -164,8 +163,8 @@ public class OverlordCompactionResourceTest
         new ClusterCompactionConfig(0.5, 10, null, true, CompactionEngine.MSQ, true),
         httpRequest
     );
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(Map.of("success", true), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(Map.of("success", true), response.getEntity());
   }
 
   @Test
@@ -179,8 +178,8 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getClusterCompactionConfig();
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(clusterConfig, response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(clusterConfig, response.getEntity());
   }
 
   @Test
@@ -208,8 +207,8 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getDatasourceCompactionSnapshot(TestDataSource.WIKI);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(snapshot, response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(snapshot, response.getEntity());
   }
 
   @Test
@@ -220,7 +219,7 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getDatasourceCompactionSnapshot(TestDataSource.KOALA);
-    Assert.assertEquals(404, response.getStatus());
+    Assertions.assertEquals(404, response.getStatus());
   }
 
   @Test
@@ -235,8 +234,8 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getDatasourceCompactionSnapshot(TestDataSource.WIKI);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(snapshot, response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(snapshot, response.getEntity());
   }
 
   @Test
@@ -253,8 +252,8 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getAllCompactionSnapshots(httpRequest);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(new CompactionStatusResponse(List.of(snapshot)), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(new CompactionStatusResponse(List.of(snapshot)), response.getEntity());
   }
 
   @Test
@@ -273,8 +272,8 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getAllCompactionSnapshots(httpRequest);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(new CompactionStatusResponse(List.of(snapshot)), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(new CompactionStatusResponse(List.of(snapshot)), response.getEntity());
   }
 
   @Test
@@ -287,8 +286,8 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getDatasourceCompactionConfig(TestDataSource.WIKI);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(wikiConfig, response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(wikiConfig, response.getEntity());
   }
 
   @Test
@@ -325,7 +324,7 @@ public class OverlordCompactionResourceTest
 
     final Response response = compactionResource
         .updateDatasourceCompactionConfig(TestDataSource.WIKI, wikiConfig, httpRequest);
-    Assert.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(200, response.getStatus());
   }
 
   @Test
@@ -354,7 +353,7 @@ public class OverlordCompactionResourceTest
 
     final Response response = compactionResource
         .deleteDatasourceCompactionConfig(TestDataSource.WIKI, httpRequest);
-    Assert.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(200, response.getStatus());
   }
 
   @Test
@@ -390,8 +389,8 @@ public class OverlordCompactionResourceTest
     replayAll();
 
     final Response response = compactionResource.getAllCompactionConfigs(httpRequest);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(new CompactionConfigsResponse(List.of(wikiConfig)), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(new CompactionConfigsResponse(List.of(wikiConfig)), response.getEntity());
   }
 
   @Test
@@ -419,26 +418,26 @@ public class OverlordCompactionResourceTest
 
     Response response = compactionResource
         .getDatasourceCompactionConfigHistory(TestDataSource.WIKI, null, null);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(toHistoryResponse(history), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(toHistoryResponse(history), response.getEntity());
 
     // Filter by count
     response = compactionResource
         .getDatasourceCompactionConfigHistory(TestDataSource.WIKI, null, 2);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(toHistoryResponse(history.subList(0, 2)), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(toHistoryResponse(history.subList(0, 2)), response.getEntity());
 
     // Filter by interval
     response = compactionResource
         .getDatasourceCompactionConfigHistory(TestDataSource.WIKI, "2025-01/P40D", null);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(toHistoryResponse(history.subList(1, 3)), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(toHistoryResponse(history.subList(1, 3)), response.getEntity());
 
     // Filter by interval and count
     response = compactionResource
         .getDatasourceCompactionConfigHistory(TestDataSource.WIKI, "2025-01/P40D", 1);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(toHistoryResponse(history.subList(1, 2)), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(toHistoryResponse(history.subList(1, 2)), response.getEntity());
   }
 
   private static CompactionConfigHistoryResponse toHistoryResponse(
@@ -450,12 +449,13 @@ public class OverlordCompactionResourceTest
 
   private void verifyInvalidInputResponse(Response response, String message)
   {
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertTrue(response.getEntity() instanceof ErrorResponse);
-    MatcherAssert.assertThat(
-        ((ErrorResponse) response.getEntity()).getUnderlyingException(),
-        DruidExceptionMatcher.invalidInput().expectMessageIs(message)
-    );
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertTrue(response.getEntity() instanceof ErrorResponse);
+    final DruidException exception = ((ErrorResponse) response.getEntity()).getUnderlyingException();
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.INVALID_INPUT, exception.getCategory());
+    Assertions.assertEquals("invalidInput", exception.getErrorCode());
+    Assertions.assertEquals(message, exception.getMessage());
   }
 
   private void setupMockRequestForUser(String user)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java
index 5070197c37a..d83ae340a4d 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordDataSourcesResourceTest.java
@@ -33,9 +33,9 @@ import org.apache.druid.server.security.AuthConfig;
 import org.apache.druid.timeline.DataSegment;
 import org.easymock.EasyMock;
 import org.joda.time.Interval;
-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 javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.core.Response;
@@ -57,7 +57,7 @@ public class OverlordDataSourcesResourceTest
 
   private OverlordDataSourcesResource dataSourcesResource;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     AuditManager auditManager = EasyMock.createStrictMock(AuditManager.class);
@@ -91,8 +91,8 @@ public class OverlordDataSourcesResourceTest
         TestDataSource.WIKI,
         "some<script>Segment"
     );
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(
         "Could not parse Segment ID[some&lt;script&gt;Segment] for DataSource[wiki]",
         response.getEntity()
     );
@@ -195,8 +195,8 @@ public class OverlordDataSourcesResourceTest
         TestDataSource.WIKI,
         "some<script>Segment"
     );
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(
         "Could not parse Segment ID[some&lt;script&gt;Segment] for DataSource[wiki]",
         response.getEntity()
     );
@@ -229,9 +229,9 @@ public class OverlordDataSourcesResourceTest
 
     final Collection<DataSegment> usedSegments =
         storageCoordinator.retrieveAllUsedSegments(TestDataSource.WIKI, Segments.INCLUDING_OVERSHADOWED);
-    Assert.assertEquals(10, usedSegments.size());
+    Assertions.assertEquals(10, usedSegments.size());
     for (DataSegment segment : usedSegments) {
-      Assert.assertEquals(version2, segment.getVersion());
+      Assertions.assertEquals(version2, segment.getVersion());
     }
   }
 
@@ -304,8 +304,8 @@ public class OverlordDataSourcesResourceTest
   {
     final Response response
         = dataSourcesResource.markNonOvershadowedSegmentsAsUsed(TestDataSource.WIKI, null);
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(
         "Invalid request payload. Specify either 'interval' or 'segmentIds', but not both."
         + " Optionally, include 'versions' only when 'interval' is provided.",
         response.getEntity()
@@ -325,38 +325,38 @@ public class OverlordDataSourcesResourceTest
         TestDataSource.WIKI,
         new SegmentsToUpdateFilter(null, null, null)
     );
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(expectedErrorMessage, response.getEntity());
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(expectedErrorMessage, response.getEntity());
 
     // interval is null and segmentIds is empty
     response = dataSourcesResource.markNonOvershadowedSegmentsAsUsed(
         TestDataSource.WIKI,
         new SegmentsToUpdateFilter(null, Collections.emptySet(), null)
     );
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(expectedErrorMessage, response.getEntity());
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(expectedErrorMessage, response.getEntity());
 
     // Both interval and segmentIds are specified
     response = dataSourcesResource.markNonOvershadowedSegmentsAsUsed(
         TestDataSource.WIKI,
         new SegmentsToUpdateFilter(Intervals.of("1000/2000"), Collections.singleton(segmentId), null)
     );
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(expectedErrorMessage, response.getEntity());
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(expectedErrorMessage, response.getEntity());
 
     // versions are specified with segmentIds
     response = dataSourcesResource.markNonOvershadowedSegmentsAsUsed(
         TestDataSource.WIKI,
         new SegmentsToUpdateFilter(null, Collections.singleton(segmentId), Collections.singletonList("v1"))
     );
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(expectedErrorMessage, response.getEntity());
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(expectedErrorMessage, response.getEntity());
   }
 
   private void verifyNumSegmentsUpdated(int expectedUpdatedCount, Response response)
   {
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(new SegmentUpdateResponse(expectedUpdatedCount), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(new SegmentUpdateResponse(expectedUpdatedCount), response.getEntity());
   }
 
   private static HttpServletRequest createHttpServletRequest()
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordRedirectInfoTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordRedirectInfoTest.java
index f9a0105c067..7dde7dab023 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordRedirectInfoTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordRedirectInfoTest.java
@@ -22,9 +22,9 @@ package org.apache.druid.indexing.overlord.http;
 import com.google.common.base.Optional;
 import org.apache.druid.indexing.overlord.DruidOverlord;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.io.UnsupportedEncodingException;
 import java.net.URL;
@@ -35,7 +35,7 @@ public class OverlordRedirectInfoTest
   private DruidOverlord overlord;
   private OverlordRedirectInfo redirectInfo;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     overlord = EasyMock.createMock(DruidOverlord.class);
@@ -47,10 +47,10 @@ public class OverlordRedirectInfoTest
   {
     EasyMock.expect(overlord.isLeader()).andReturn(true).anyTimes();
     EasyMock.replay(overlord);
-    Assert.assertTrue(redirectInfo.doLocal(null));
-    Assert.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/leader"));
-    Assert.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/isLeader"));
-    Assert.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/other/path"));
+    Assertions.assertTrue(redirectInfo.doLocal(null));
+    Assertions.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/leader"));
+    Assertions.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/isLeader"));
+    Assertions.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/other/path"));
     EasyMock.verify(overlord);
   }
 
@@ -59,10 +59,10 @@ public class OverlordRedirectInfoTest
   {
     EasyMock.expect(overlord.isLeader()).andReturn(false).anyTimes();
     EasyMock.replay(overlord);
-    Assert.assertFalse(redirectInfo.doLocal(null));
-    Assert.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/leader"));
-    Assert.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/isLeader"));
-    Assert.assertFalse(redirectInfo.doLocal("/druid/indexer/v1/other/path"));
+    Assertions.assertFalse(redirectInfo.doLocal(null));
+    Assertions.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/leader"));
+    Assertions.assertTrue(redirectInfo.doLocal("/druid/indexer/v1/isLeader"));
+    Assertions.assertFalse(redirectInfo.doLocal("/druid/indexer/v1/other/path"));
     EasyMock.verify(overlord);
   }
 
@@ -72,7 +72,7 @@ public class OverlordRedirectInfoTest
     EasyMock.expect(overlord.getRedirectLocation()).andReturn(Optional.absent()).anyTimes();
     EasyMock.replay(overlord);
     URL url = redirectInfo.getRedirectURL("query", "/request");
-    Assert.assertNull(url);
+    Assertions.assertNull(url);
     EasyMock.verify(overlord);
   }
 
@@ -85,7 +85,7 @@ public class OverlordRedirectInfoTest
     EasyMock.expect(overlord.getRedirectLocation()).andReturn(Optional.of(host)).anyTimes();
     EasyMock.replay(overlord);
     URL url = redirectInfo.getRedirectURL(query, request);
-    Assert.assertEquals("http://localhost/request?foo=bar&x=y", url.toString());
+    Assertions.assertEquals("http://localhost/request?foo=bar&x=y", url.toString());
     EasyMock.verify(overlord);
   }
 
@@ -101,7 +101,7 @@ public class OverlordRedirectInfoTest
     EasyMock.expect(overlord.getRedirectLocation()).andReturn(Optional.of(host)).anyTimes();
     EasyMock.replay(overlord);
     URL url = redirectInfo.getRedirectURL(null, request);
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "http://localhost/druid/indexer/v1/task/index_hadoop_datasource_2017-07-12T07%3A43%3A01.495Z/status",
         url.toString()
     );
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordResourceTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordResourceTest.java
index dd295fc979c..b9304b3651d 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordResourceTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordResourceTest.java
@@ -81,12 +81,10 @@ import org.joda.time.Duration;
 import org.joda.time.Interval;
 import org.joda.time.Period;
 import org.joda.time.chrono.ISOChronology;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.WebApplicationException;
@@ -117,10 +115,7 @@ public class OverlordResourceTest
   private WorkerTaskRunnerQueryAdapter workerTaskRunnerQueryAdapter;
   private AuditManager auditManager;
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
-  @Before
+  @BeforeEach
   public void setUp()
   {
     taskRunner = EasyMock.createMock(TaskRunner.class);
@@ -193,7 +188,7 @@ public class OverlordResourceTest
     );
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     EasyMock.verify(
@@ -233,8 +228,8 @@ public class OverlordResourceTest
     replayAll();
 
     final Response response = overlordResource.getLeader();
-    Assert.assertEquals("boz", response.getEntity());
-    Assert.assertEquals(200, response.getStatus());
+    Assertions.assertEquals("boz", response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
   }
 
   @Test
@@ -246,13 +241,13 @@ public class OverlordResourceTest
 
     // true
     final Response response1 = overlordResource.isLeader();
-    Assert.assertEquals(ImmutableMap.of("leader", true), response1.getEntity());
-    Assert.assertEquals(200, response1.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("leader", true), response1.getEntity());
+    Assertions.assertEquals(200, response1.getStatus());
 
     // false
     final Response response2 = overlordResource.isLeader();
-    Assert.assertEquals(ImmutableMap.of("leader", false), response2.getEntity());
-    Assert.assertEquals(404, response2.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("leader", false), response2.getEntity());
+    Assertions.assertEquals(404, response2.getStatus());
   }
 
   @Test
@@ -284,8 +279,8 @@ public class OverlordResourceTest
 
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource.getWaitingTasks(req)
                                                                                   .getEntity();
-    Assert.assertEquals(1, responseObjects.size());
-    Assert.assertEquals("id_2", responseObjects.get(0).getId());
+    Assertions.assertEquals(1, responseObjects.size());
+    Assertions.assertEquals("id_2", responseObjects.get(0).getId());
   }
 
   @Test
@@ -309,9 +304,9 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List) overlordResource
         .getCompleteTasks(null, req).getEntity();
 
-    Assert.assertEquals(2, responseObjects.size());
-    Assert.assertEquals(tasksIds.get(1), responseObjects.get(0).getId());
-    Assert.assertEquals(tasksIds.get(2), responseObjects.get(1).getId());
+    Assertions.assertEquals(2, responseObjects.size());
+    Assertions.assertEquals(tasksIds.get(1), responseObjects.get(0).getId());
+    Assertions.assertEquals(tasksIds.get(2), responseObjects.get(1).getId());
   }
 
   @Test
@@ -344,8 +339,8 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List) overlordResource.getRunningTasks(null, req)
                                                                   .getEntity();
 
-    Assert.assertEquals(1, responseObjects.size());
-    Assert.assertEquals(tasksIds.get(1), responseObjects.get(0).getId());
+    Assertions.assertEquals(1, responseObjects.size());
+    Assertions.assertEquals(tasksIds.get(1), responseObjects.get(0).getId());
   }
 
   @Test
@@ -364,8 +359,8 @@ public class OverlordResourceTest
     replayAll();
 
     final List<TaskStatusPlus> activeTasks = taskQueryTool.getAllActiveTasks();
-    Assert.assertEquals(2, activeTasks.size());
-    Assert.assertTrue(activeTasks.stream().allMatch(status -> status.getStatusCode().equals(TaskState.RUNNING)));
+    Assertions.assertEquals(2, activeTasks.size());
+    Assertions.assertTrue(activeTasks.stream().allMatch(status -> status.getStatusCode().equals(TaskState.RUNNING)));
   }
 
   @Test
@@ -405,7 +400,7 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource
         .getTasks(null, null, null, null, null, req)
         .getEntity();
-    Assert.assertEquals(4, responseObjects.size());
+    Assertions.assertEquals(4, responseObjects.size());
   }
 
   @Test
@@ -445,9 +440,9 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource
         .getTasks(null, "allow", null, null, null, req)
         .getEntity();
-    Assert.assertEquals(7, responseObjects.size());
-    Assert.assertEquals("id_5", responseObjects.get(0).getId());
-    Assert.assertEquals("DataSource Check", "allow", responseObjects.get(0).getDataSource());
+    Assertions.assertEquals(7, responseObjects.size());
+    Assertions.assertEquals("id_5", responseObjects.get(0).getId());
+    Assertions.assertEquals("allow", responseObjects.get(0).getDataSource(), "DataSource Check");
   }
 
   @Test
@@ -490,8 +485,8 @@ public class OverlordResourceTest
             null,
             req
         ).getEntity();
-    Assert.assertEquals(1, responseObjects.size());
-    Assert.assertEquals("id_2", responseObjects.get(0).getId());
+    Assertions.assertEquals(1, responseObjects.size());
+    Assertions.assertEquals("id_2", responseObjects.get(0).getId());
   }
 
   @Test
@@ -531,9 +526,9 @@ public class OverlordResourceTest
         .getTasks("running", "allow", null, null, null, req)
         .getEntity();
 
-    Assert.assertEquals(2, responseObjects.size());
-    Assert.assertEquals(tasksIds.get(0), responseObjects.get(0).getId());
-    Assert.assertEquals("DataSource Check", "allow", responseObjects.get(0).getDataSource());
+    Assertions.assertEquals(2, responseObjects.size());
+    Assertions.assertEquals(tasksIds.get(0), responseObjects.get(0).getId());
+    Assertions.assertEquals("allow", responseObjects.get(0).getDataSource(), "DataSource Check");
   }
 
   @Test
@@ -573,9 +568,9 @@ public class OverlordResourceTest
         .getTasks("pending", null, null, null, null, req)
         .getEntity();
 
-    Assert.assertEquals(1, responseObjects.size());
-    Assert.assertEquals(tasksIds.get(1), responseObjects.get(0).getId());
-    Assert.assertEquals("DataSource Check", "allow", responseObjects.get(0).getDataSource());
+    Assertions.assertEquals(1, responseObjects.size());
+    Assertions.assertEquals(tasksIds.get(1), responseObjects.get(0).getId());
+    Assertions.assertEquals("allow", responseObjects.get(0).getDataSource(), "DataSource Check");
   }
 
   @Test
@@ -599,9 +594,9 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource
         .getTasks("complete", null, null, null, null, req)
         .getEntity();
-    Assert.assertEquals(2, responseObjects.size());
-    Assert.assertEquals("id_1", responseObjects.get(0).getId());
-    Assert.assertTrue("DataSource Check", "allow".equals(responseObjects.get(0).getDataSource()));
+    Assertions.assertEquals(2, responseObjects.size());
+    Assertions.assertEquals("id_1", responseObjects.get(0).getId());
+    Assertions.assertTrue("allow".equals(responseObjects.get(0).getDataSource()), "DataSource Check");
   }
 
   @Test
@@ -628,9 +623,9 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource
         .getTasks("complete", null, interval, null, null, req)
         .getEntity();
-    Assert.assertEquals(2, responseObjects.size());
-    Assert.assertEquals("id_2", responseObjects.get(0).getId());
-    Assert.assertEquals("DataSource Check", "allow", responseObjects.get(0).getDataSource());
+    Assertions.assertEquals(2, responseObjects.size());
+    Assertions.assertEquals("id_2", responseObjects.get(0).getId());
+    Assertions.assertEquals("allow", responseObjects.get(0).getDataSource(), "DataSource Check");
   }
 
   @Test
@@ -676,9 +671,9 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource
         .getTasks(null, null, null, null, null, req)
         .getEntity();
-    Assert.assertEquals(2, responseObjects.size());
+    Assertions.assertEquals(2, responseObjects.size());
     for (TaskStatusPlus taskStatus : responseObjects) {
-      Assert.assertEquals(Datasources.WIKIPEDIA, taskStatus.getDataSource());
+      Assertions.assertEquals(Datasources.WIKIPEDIA, taskStatus.getDataSource());
     }
   }
 
@@ -724,9 +719,9 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource
         .getTasks(null, null, null, null, "to-return", req)
         .getEntity();
-    Assert.assertEquals(1, responseObjects.size());
+    Assertions.assertEquals(1, responseObjects.size());
     for (TaskStatusPlus taskStatus : responseObjects) {
-      Assert.assertEquals("to-return", taskStatus.getType());
+      Assertions.assertEquals("to-return", taskStatus.getType());
     }
   }
 
@@ -740,7 +735,7 @@ public class OverlordResourceTest
     replayAll();
 
     // Verify that only the tasks of read access datasource are returned
-    Assert.assertThrows(
+    Assertions.assertThrows(
         WebApplicationException.class,
         () -> overlordResource.getTasks(null, Datasources.BUZZFEED, null, null, null, req)
     );
@@ -770,9 +765,9 @@ public class OverlordResourceTest
     List<TaskStatusPlus> responseObjects = (List<TaskStatusPlus>) overlordResource
         .getTasks("complete", null, null, null, null, req)
         .getEntity();
-    Assert.assertEquals(2, responseObjects.size());
-    Assert.assertEquals("id_1", responseObjects.get(0).getId());
-    Assert.assertEquals("DataSource Check", "allow", responseObjects.get(0).getDataSource());
+    Assertions.assertEquals(2, responseObjects.size());
+    Assertions.assertEquals("id_1", responseObjects.get(0).getId());
+    Assertions.assertEquals("allow", responseObjects.get(0).getDataSource(), "DataSource Check");
   }
 
   @Test
@@ -783,7 +778,7 @@ public class OverlordResourceTest
     Object responseObject = overlordResource
         .getTasks("blah", "ds_test", null, null, null, req)
         .getEntity();
-    Assert.assertEquals(
+    Assertions.assertEquals(
         "Invalid task state[blah]. Must be one of [pending, waiting, running, complete].",
         responseObject.toString()
     );
@@ -792,14 +787,13 @@ public class OverlordResourceTest
   @Test
   public void testSecuredTaskPost()
   {
-    expectedException.expect(ForbiddenException.class);
     expectAuthorizationTokenCheck();
     EasyMock.expect(authConfig.isEnableInputSourceSecurity()).andReturn(false);
 
     replayAll();
 
-    Task task = NoopTask.create();
-    overlordResource.taskPost(task, req);
+    final Task task = NoopTask.create();
+    Assertions.assertThrows(ForbiddenException.class, () -> overlordResource.taskPost(task, req));
   }
 
   @Test
@@ -831,12 +825,12 @@ public class OverlordResourceTest
     Task task = new KillUnusedSegmentsTask("kill_all", "allow", Intervals.ETERNITY, null, null, 10, null, null);
     overlordResource.taskPost(task, req);
 
-    Assert.assertTrue(auditEntryCapture.hasCaptured());
+    Assertions.assertTrue(auditEntryCapture.hasCaptured());
     AuditEntry auditEntry = auditEntryCapture.getValue();
-    Assert.assertEquals(username, auditEntry.getAuditInfo().getAuthor());
-    Assert.assertEquals("killing segments", auditEntry.getAuditInfo().getComment());
-    Assert.assertEquals("druid", auditEntry.getAuditInfo().getIdentity());
-    Assert.assertEquals("127.0.0.1", auditEntry.getAuditInfo().getIp());
+    Assertions.assertEquals(username, auditEntry.getAuditInfo().getAuthor());
+    Assertions.assertEquals("killing segments", auditEntry.getAuditInfo().getComment());
+    Assertions.assertEquals("druid", auditEntry.getAuditInfo().getIdentity());
+    Assertions.assertEquals("127.0.0.1", auditEntry.getAuditInfo().getIp());
   }
 
   @Test
@@ -848,10 +842,8 @@ public class OverlordResourceTest
     replayAll();
 
     // Verify that taskPost fails for user who has only datasource read access
-    Task task = NoopTask.forDatasource(Datasources.WIKIPEDIA);
-    expectedException.expect(ForbiddenException.class);
-    expectedException.expect(ForbiddenException.class);
-    overlordResource.taskPost(task, req);
+    final Task task = NoopTask.forDatasource(Datasources.WIKIPEDIA);
+    Assertions.assertThrows(ForbiddenException.class, () -> overlordResource.taskPost(task, req));
   }
 
   @Test
@@ -873,8 +865,8 @@ public class OverlordResourceTest
 
     Response response = overlordResource
         .killPendingSegments("allow", new Interval(DateTimes.MIN, DateTimes.nowUtc()).toString(), req);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("numDeleted", 2), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("numDeleted", 2), response.getEntity());
   }
 
   @Test
@@ -899,8 +891,8 @@ public class OverlordResourceTest
     Response response = overlordResource
         .killPendingSegments("allow", new Interval(DateTimes.MIN, DateTimes.nowUtc()).toString(), req);
 
-    Assert.assertEquals(400, response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("error", exceptionMsg), response.getEntity());
+    Assertions.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("error", exceptionMsg), response.getEntity());
   }
 
   @Test
@@ -925,8 +917,8 @@ public class OverlordResourceTest
     Response response = overlordResource
         .killPendingSegments("allow", new Interval(DateTimes.MIN, DateTimes.nowUtc()).toString(), req);
 
-    Assert.assertEquals(500, response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("error", exceptionMsg), response.getEntity());
+    Assertions.assertEquals(500, response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("error", exceptionMsg), response.getEntity());
   }
 
   @Test
@@ -951,8 +943,8 @@ public class OverlordResourceTest
     Response response = overlordResource
         .killPendingSegments("allow", new Interval(DateTimes.MIN, DateTimes.nowUtc()).toString(), req);
 
-    Assert.assertEquals(500, response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("error", exceptionMsg), response.getEntity());
+    Assertions.assertEquals(500, response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("error", exceptionMsg), response.getEntity());
   }
 
   @Test
@@ -967,8 +959,8 @@ public class OverlordResourceTest
     Response response = overlordResource
         .killPendingSegments("allow", new Interval(DateTimes.MIN, DateTimes.nowUtc()).toString(), req);
 
-    Assert.assertEquals(503, response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("error", "overlord is not the leader or not initialized yet"), response.getEntity());
+    Assertions.assertEquals(503, response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("error", "overlord is not the leader or not initialized yet"), response.getEntity());
   }
 
   @Test
@@ -994,14 +986,14 @@ public class OverlordResourceTest
         TestHelper.makeJsonMapper().writeValueAsString(response1.getEntity()),
         TaskPayloadResponse.class
     );
-    Assert.assertEquals(new TaskPayloadResponse("mytask", task), taskPayloadResponse1);
+    Assertions.assertEquals(new TaskPayloadResponse("mytask", task), taskPayloadResponse1);
 
     final Response response2 = overlordResource.getTaskPayload("othertask");
     final TaskPayloadResponse taskPayloadResponse2 = TestHelper.makeJsonMapper().readValue(
         TestHelper.makeJsonMapper().writeValueAsString(response2.getEntity()),
         TaskPayloadResponse.class
     );
-    Assert.assertEquals(new TaskPayloadResponse("othertask", null), taskPayloadResponse2);
+    Assertions.assertEquals(new TaskPayloadResponse("othertask", null), taskPayloadResponse2);
   }
 
   @Test
@@ -1042,9 +1034,7 @@ public class OverlordResourceTest
         TestHelper.makeJsonMapper().writeValueAsString(response1.getEntity()),
         TaskStatusResponse.class
     );
-    TaskStatusPlus tsp = taskStatusResponse1.getStatus();
-    Assert.assertEquals(tsp.getStatusCode(), tsp.getStatus());
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new TaskStatusResponse(
             taskId,
             new TaskStatusPlus(
@@ -1069,7 +1059,7 @@ public class OverlordResourceTest
         TestHelper.makeJsonMapper().writeValueAsString(response2.getEntity()),
         TaskStatusResponse.class
     );
-    Assert.assertEquals(new TaskStatusResponse("othertask", null), taskStatusResponse2);
+    Assertions.assertEquals(new TaskStatusResponse("othertask", null), taskStatusResponse2);
   }
 
   @Test
@@ -1091,7 +1081,7 @@ public class OverlordResourceTest
     replayAll();
 
     final Response response = overlordResource.getDatasourceLockedIntervals(lockFilterPolicies);
-    Assert.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(200, response.getStatus());
 
     final ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
     Map<String, List<Interval>> observedIntervals = jsonMapper.readValue(
@@ -1099,7 +1089,7 @@ public class OverlordResourceTest
         new TypeReference<>() {}
     );
 
-    Assert.assertEquals(expectedIntervals, observedIntervals);
+    Assertions.assertEquals(expectedIntervals, observedIntervals);
   }
 
   @Test
@@ -1108,10 +1098,10 @@ public class OverlordResourceTest
     replayAll();
 
     Response response = overlordResource.getDatasourceLockedIntervals(null);
-    Assert.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(400, response.getStatus());
 
     response = overlordResource.getDatasourceLockedIntervals(Collections.emptyList());
-    Assert.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(400, response.getStatus());
   }
 
   @Test
@@ -1147,7 +1137,7 @@ public class OverlordResourceTest
     replayAll();
 
     final Response response = overlordResource.getActiveLocks(lockFilterPolicies);
-    Assert.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(200, response.getStatus());
 
     final ObjectMapper jsonMapper = TestHelper.makeJsonMapper();
     Map<String, List<TaskLock>> observedLocks = jsonMapper.readValue(
@@ -1157,7 +1147,7 @@ public class OverlordResourceTest
         }
     ).getDatasourceToLocks();
 
-    Assert.assertEquals(expectedLocks, observedLocks);
+    Assertions.assertEquals(expectedLocks, observedLocks);
   }
 
   @Test
@@ -1166,10 +1156,10 @@ public class OverlordResourceTest
     replayAll();
 
     Response response = overlordResource.getActiveLocks(null);
-    Assert.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(400, response.getStatus());
 
     response = overlordResource.getActiveLocks(Collections.emptyList());
-    Assert.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(400, response.getStatus());
   }
 
   @Test
@@ -1191,7 +1181,7 @@ public class OverlordResourceTest
     final Map<String, Integer> response = (Map<String, Integer>) overlordResource
         .doShutdown("id_1")
         .getEntity();
-    Assert.assertEquals("id_1", response.get("task"));
+    Assertions.assertEquals("id_1", response.get("task"));
   }
 
   @Test
@@ -1229,7 +1219,7 @@ public class OverlordResourceTest
     final Map<String, String> response = (Map<String, String>) overlordResource
         .shutdownTasksForDataSource("datasource")
         .getEntity();
-    Assert.assertEquals("datasource", response.get("dataSource"));
+    Assertions.assertEquals("datasource", response.get("dataSource"));
   }
 
   @Test
@@ -1243,7 +1233,7 @@ public class OverlordResourceTest
     replayAll();
 
     final Response response = overlordResource.shutdownTasksForDataSource("notExisting");
-    Assert.assertEquals(Status.NOT_FOUND.getStatusCode(), response.getStatus());
+    Assertions.assertEquals(Status.NOT_FOUND.getStatusCode(), response.getStatus());
   }
 
   @Test
@@ -1258,8 +1248,8 @@ public class OverlordResourceTest
 
     final Response response = overlordResource.enableWorker(host);
 
-    Assert.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
-    Assert.assertEquals(ImmutableMap.of(host, "enabled"), response.getEntity());
+    Assertions.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of(host, "enabled"), response.getEntity());
   }
 
   @Test
@@ -1274,8 +1264,8 @@ public class OverlordResourceTest
 
     final Response response = overlordResource.disableWorker(host);
 
-    Assert.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
-    Assert.assertEquals(ImmutableMap.of(host, "disabled"), response.getEntity());
+    Assertions.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of(host, "disabled"), response.getEntity());
   }
 
   @Test
@@ -1290,8 +1280,8 @@ public class OverlordResourceTest
 
     final Response response = overlordResource.enableWorker(host);
 
-    Assert.assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.getCode(), response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("error", "Worker API returns error!"), response.getEntity());
+    Assertions.assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.getCode(), response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("error", "Worker API returns error!"), response.getEntity());
   }
 
   @Test
@@ -1306,8 +1296,8 @@ public class OverlordResourceTest
 
     final Response response = overlordResource.disableWorker(host);
 
-    Assert.assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.getCode(), response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("error", "Worker API returns error!"), response.getEntity());
+    Assertions.assertEquals(HttpResponseStatus.INTERNAL_SERVER_ERROR.getCode(), response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("error", "Worker API returns error!"), response.getEntity());
   }
 
   @Test
@@ -1316,7 +1306,7 @@ public class OverlordResourceTest
     EasyMock.expect(overlord.isLeader()).andReturn(false);
     replayAll();
     final Response response = overlordResource.getTotalWorkerCapacity();
-    Assert.assertEquals(HttpResponseStatus.SERVICE_UNAVAILABLE.getCode(), response.getStatus());
+    Assertions.assertEquals(HttpResponseStatus.SERVICE_UNAVAILABLE.getCode(), response.getStatus());
   }
 
   @Test
@@ -1334,10 +1324,10 @@ public class OverlordResourceTest
     replayAll();
 
     final Response response = overlordResource.getTotalWorkerCapacity();
-    Assert.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
-    Assert.assertEquals(-1, ((TotalWorkerCapacityResponse) response.getEntity()).getCurrentClusterCapacity());
-    Assert.assertEquals(-1, ((TotalWorkerCapacityResponse) response.getEntity()).getUsedClusterCapacity());
-    Assert.assertEquals(-1, ((TotalWorkerCapacityResponse) response.getEntity()).getMaximumCapacityWithAutoScale());
+    Assertions.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
+    Assertions.assertEquals(-1, ((TotalWorkerCapacityResponse) response.getEntity()).getCurrentClusterCapacity());
+    Assertions.assertEquals(-1, ((TotalWorkerCapacityResponse) response.getEntity()).getUsedClusterCapacity());
+    Assertions.assertEquals(-1, ((TotalWorkerCapacityResponse) response.getEntity()).getMaximumCapacityWithAutoScale());
   }
 
   @Test
@@ -1357,10 +1347,10 @@ public class OverlordResourceTest
     replayAll();
 
     final Response response = overlordResource.getTotalWorkerCapacity();
-    Assert.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
-    Assert.assertEquals(expectedWorkerCapacity, ((TotalWorkerCapacityResponse) response.getEntity()).getCurrentClusterCapacity());
-    Assert.assertEquals(expectedWorkerCapacity, ((TotalWorkerCapacityResponse) response.getEntity()).getUsedClusterCapacity());
-    Assert.assertEquals(expectedWorkerCapacityWithAutoscale, ((TotalWorkerCapacityResponse) response.getEntity()).getMaximumCapacityWithAutoScale());
+    Assertions.assertEquals(HttpResponseStatus.OK.getCode(), response.getStatus());
+    Assertions.assertEquals(expectedWorkerCapacity, ((TotalWorkerCapacityResponse) response.getEntity()).getCurrentClusterCapacity());
+    Assertions.assertEquals(expectedWorkerCapacity, ((TotalWorkerCapacityResponse) response.getEntity()).getUsedClusterCapacity());
+    Assertions.assertEquals(expectedWorkerCapacityWithAutoscale, ((TotalWorkerCapacityResponse) response.getEntity()).getMaximumCapacityWithAutoScale());
   }
 
   @Test
@@ -1388,7 +1378,7 @@ public class OverlordResourceTest
         new ResourceAction(new Resource(inputSourceType, ResourceType.EXTERNAL), Action.READ)
     );
     Set<ResourceAction> resourceActions = overlordResource.getNeededResourceActionsForTask(task);
-    Assert.assertEquals(expectedResourceActions, resourceActions);
+    Assertions.assertEquals(expectedResourceActions, resourceActions);
   }
 
   @Test
@@ -1407,12 +1397,12 @@ public class OverlordResourceTest
     EasyMock.replay(task);
     replayAll();
 
-    final UOE e = Assert.assertThrows(
+    final UOE e = Assertions.assertThrows(
         UOE.class,
         () -> overlordResource.getNeededResourceActionsForTask(task)
     );
 
-    Assert.assertEquals(expectedException, e);
+    Assertions.assertEquals(expectedException, e);
   }
 
   @Test
@@ -1438,7 +1428,7 @@ public class OverlordResourceTest
         new ResourceAction(new Resource(dataSource, ResourceType.DATASOURCE), Action.WRITE)
     );
     Set<ResourceAction> resourceActions = overlordResource.getNeededResourceActionsForTask(task);
-    Assert.assertEquals(expectedResourceActions, resourceActions);
+    Assertions.assertEquals(expectedResourceActions, resourceActions);
   }
 
   @Test
@@ -1452,7 +1442,7 @@ public class OverlordResourceTest
 
     final Object response = overlordResource.getMultipleTaskStatuses(ImmutableSet.of("task"))
                                             .getEntity();
-    Assert.assertEquals(ImmutableMap.of("task", TaskStatus.running("task")), response);
+    Assertions.assertEquals(ImmutableMap.of("task", TaskStatus.running("task")), response);
   }
 
   @Test
@@ -1465,7 +1455,7 @@ public class OverlordResourceTest
 
     final Object response = overlordResource.getMultipleTaskStatuses(ImmutableSet.of("task"))
                                             .getEntity();
-    Assert.assertEquals(ImmutableMap.of("task", TaskStatus.running("task")), response);
+    Assertions.assertEquals(ImmutableMap.of("task", TaskStatus.running("task")), response);
   }
 
   @Test
@@ -1475,8 +1465,8 @@ public class OverlordResourceTest
     OverlordResource overlordResource =
         new OverlordResource(null, null, null, null, null, null, null, null, null, null);
     final Response response = overlordResource.getTaskSegments("taskId");
-    Assert.assertEquals(404, response.getStatus());
-    Assert.assertEquals(
+    Assertions.assertEquals(404, response.getStatus());
+    Assertions.assertEquals(
         Collections.singletonMap(
             "error",
             "Segment IDs committed by a task action are not persisted anymore."
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordTest.java
index e7dbc561bee..1bca81b8759 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/OverlordTest.java
@@ -84,10 +84,11 @@ import org.apache.druid.server.security.AuthenticationResult;
 import org.apache.druid.utils.CloseableUtils;
 import org.easymock.EasyMock;
 import org.joda.time.Period;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
 
 import javax.annotation.Nullable;
 import javax.servlet.http.HttpServletRequest;
@@ -151,7 +152,7 @@ public class OverlordTest
     CloseableUtils.closeAndWrapExceptions(server);
   }
 
-  @Before
+  @BeforeEach
   public void setUp() throws Exception
   {
     req = EasyMock.createMock(HttpServletRequest.class);
@@ -267,7 +268,8 @@ public class OverlordTest
     EmittingLogger.registerEmitter(serviceEmitter);
   }
 
-  @Test(timeout = 60_000L)
+  @Timeout(60)
+  @Test
   public void testOverlordRun() throws Exception
   {
     // basic task master lifecycle test
@@ -275,8 +277,8 @@ public class OverlordTest
     while (!overlord.isLeader()) {
       Thread.sleep(10);
     }
-    Assert.assertEquals(overlord.getCurrentLeader(), druidNode.getHostAndPort());
-    Assert.assertEquals(Optional.absent(), overlord.getRedirectLocation());
+    Assertions.assertEquals(druidNode.getHostAndPort(), overlord.getCurrentLeader());
+    Assertions.assertEquals(Optional.absent(), overlord.getRedirectLocation());
 
     final TaskQueryTool taskQueryTool
         = new TaskQueryTool(taskStorage, taskLockbox, taskMaster, null);
@@ -297,7 +299,7 @@ public class OverlordTest
         new AuthConfig()
     );
     Response response = overlordResource.getLeader();
-    Assert.assertEquals(druidNode.getHostAndPort(), response.getEntity());
+    Assertions.assertEquals(druidNode.getHostAndPort(), response.getEntity());
 
     // BadTask must fail due to null task lock
     waitForTaskStatus(badTaskId, TaskState.FAILED);
@@ -307,25 +309,25 @@ public class OverlordTest
     waitForTaskStatus(goodTaskId, TaskState.SUCCESS);
 
     response = overlordResource.taskPost(task0, req);
-    Assert.assertEquals(200, response.getStatus());
-    Assert.assertEquals(ImmutableMap.of("task", taskId0), response.getEntity());
+    Assertions.assertEquals(200, response.getStatus());
+    Assertions.assertEquals(ImmutableMap.of("task", taskId0), response.getEntity());
 
     // Duplicate task - should fail
     response = overlordResource.taskPost(task0, req);
-    Assert.assertEquals(400, response.getStatus());
+    Assertions.assertEquals(400, response.getStatus());
 
     // Task payload for task_0 should be present in taskStorage
     response = overlordResource.getTaskPayload(taskId0);
-    Assert.assertEquals(task0, ((TaskPayloadResponse) response.getEntity()).getPayload());
+    Assertions.assertEquals(task0, ((TaskPayloadResponse) response.getEntity()).getPayload());
 
     // Task not present in taskStorage - should fail
     response = overlordResource.getTaskPayload("whatever");
-    Assert.assertEquals(404, response.getStatus());
+    Assertions.assertEquals(404, response.getStatus());
 
     // Task status of the submitted task should be running
     response = overlordResource.getTaskStatus(taskId0);
-    Assert.assertEquals(taskId0, ((TaskStatusResponse) response.getEntity()).getTask());
-    Assert.assertEquals(
+    Assertions.assertEquals(taskId0, ((TaskStatusResponse) response.getEntity()).getTask());
+    Assertions.assertEquals(
         TaskStatus.running(taskId0).getStatusCode(),
         ((TaskStatusResponse) response.getEntity()).getStatus().getStatusCode()
     );
@@ -343,11 +345,11 @@ public class OverlordTest
 
     response = overlordResource.getRunningTasks(null, req);
     // 1 task that was manually inserted should be in running state
-    Assert.assertEquals(1, (((List) response.getEntity()).size()));
+    Assertions.assertEquals(1, (((List) response.getEntity()).size()));
     final TaskStatusPlus taskResponseObject = ((List<TaskStatusPlus>) response
         .getEntity()).get(0);
-    Assert.assertEquals(taskId1, taskResponseObject.getId());
-    Assert.assertEquals(TASK_LOCATION, taskResponseObject.getLocation());
+    Assertions.assertEquals(taskId1, taskResponseObject.getId());
+    Assertions.assertEquals(TASK_LOCATION, taskResponseObject.getLocation());
 
     // Simulate completion of task_1
     taskCompletionCountDownLatches.get(taskId1).countDown();
@@ -356,15 +358,15 @@ public class OverlordTest
 
     // should return number of tasks which are not in running state
     response = overlordResource.getCompleteTasks(null, req);
-    Assert.assertEquals(4, (((List) response.getEntity()).size()));
+    Assertions.assertEquals(4, (((List) response.getEntity()).size()));
 
     response = overlordResource.getCompleteTasks(1, req);
-    Assert.assertEquals(1, (((List) response.getEntity()).size()));
-    Assert.assertEquals(1, taskMaster.getStats().rowCount());
+    Assertions.assertEquals(1, (((List) response.getEntity()).size()));
+    Assertions.assertEquals(1, taskMaster.getStats().rowCount());
 
     overlord.stop();
-    Assert.assertFalse(overlord.isLeader());
-    Assert.assertEquals(0, taskMaster.getStats().rowCount());
+    Assertions.assertFalse(overlord.isLeader());
+    Assertions.assertEquals(0, taskMaster.getStats().rowCount());
 
     EasyMock.verify(taskActionClientFactory);
   }
@@ -384,7 +386,7 @@ public class OverlordTest
     }
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     tearDownServerAndCurator();
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/OverlordSecurityResourceFilterTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/OverlordSecurityResourceFilterTest.java
index 2912e1da02e..982289684ac 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/OverlordSecurityResourceFilterTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/OverlordSecurityResourceFilterTest.java
@@ -39,22 +39,23 @@ import org.apache.druid.server.http.security.ResourceFilterTestHelper;
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.apache.druid.server.security.ForbiddenException;
 import org.easymock.EasyMock;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.regex.Pattern;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass(name = "{index}: requestPath={0}, requestMethod={1}, resourceFilter={2}")
+@MethodSource("data")
 public class OverlordSecurityResourceFilterTest extends ResourceFilterTestHelper
 {
   private static final Pattern WORD = Pattern.compile("\\w+");
 
-  @Parameterized.Parameters(name = "{index}: requestPath={0}, requestMethod={1}, resourceFilter={2}")
   public static Collection<Object[]> data()
   {
     return ImmutableList.copyOf(
@@ -100,7 +101,7 @@ public class OverlordSecurityResourceFilterTest extends ResourceFilterTestHelper
     this.injector = injector;
   }
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     if (resourceFilter instanceof TaskResourceFilter && !mockedOnceTsqa) {
@@ -192,18 +193,13 @@ public class OverlordSecurityResourceFilterTest extends ResourceFilterTestHelper
     resourceFilter.getRequestFilter().filter(request);
   }
 
-  @Test(expected = ForbiddenException.class)
+  @Test
   public void testDatasourcesResourcesFilteringNoAccess()
   {
     setUpMockExpectations(requestPath, false, requestMethod);
     EasyMock.expect(request.getEntity(Task.class)).andReturn(noopTask).anyTimes();
     EasyMock.replay(req, request, authorizerMapper);
-    try {
-      resourceFilter.getRequestFilter().filter(request);
-    }
-    catch (ForbiddenException e) {
-      throw e;
-    }
+    Assertions.assertThrows(ForbiddenException.class, () -> resourceFilter.getRequestFilter().filter(request));
   }
 
   @Test
@@ -214,7 +210,7 @@ public class OverlordSecurityResourceFilterTest extends ResourceFilterTestHelper
     EasyMock.replay(req, request, authorizerMapper);
   }
 
-  @After
+  @AfterEach
   public void tearDown()
   {
     EasyMock.verify(req, request, authorizerMapper);
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/SupervisorResourceFilterTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/SupervisorResourceFilterTest.java
index dcf1d26e6d1..e2e2e071dbc 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/SupervisorResourceFilterTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/SupervisorResourceFilterTest.java
@@ -33,9 +33,9 @@ import org.apache.druid.server.security.ForbiddenException;
 import org.apache.druid.server.security.Resource;
 import org.apache.druid.server.security.ResourceType;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.ws.rs.WebApplicationException;
@@ -62,7 +62,7 @@ public class SupervisorResourceFilterTest
 
   private List<Object> mocksToVerify;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     supervisorManager = EasyMock.createMock(SupervisorManager.class);
@@ -78,7 +78,7 @@ public class SupervisorResourceFilterTest
   {
     setExpectations("/druid/indexer/v1/supervisor/datasource1", "GET", "datasource1", Action.READ, true);
     ContainerRequest filteredRequest = resourceFilter.filter(containerRequest);
-    Assert.assertNotNull(filteredRequest);
+    Assertions.assertNotNull(filteredRequest);
     verifyMocks();
   }
 
@@ -94,7 +94,7 @@ public class SupervisorResourceFilterTest
     catch (ForbiddenException e) {
       expected = e;
     }
-    Assert.assertNotNull(expected);
+    Assertions.assertNotNull(expected);
     verifyMocks();
   }
 
@@ -103,7 +103,7 @@ public class SupervisorResourceFilterTest
   {
     setExpectations("/druid/indexer/v1/supervisor/datasource1", "POST", "datasource1", Action.WRITE, true);
     ContainerRequest filteredRequest = resourceFilter.filter(containerRequest);
-    Assert.assertNotNull(filteredRequest);
+    Assertions.assertNotNull(filteredRequest);
     verifyMocks();
   }
 
@@ -119,7 +119,7 @@ public class SupervisorResourceFilterTest
     catch (ForbiddenException e) {
       expected = e;
     }
-    Assert.assertNotNull(expected);
+    Assertions.assertNotNull(expected);
     verifyMocks();
   }
 
@@ -150,8 +150,8 @@ public class SupervisorResourceFilterTest
       expected = e;
     }
 
-    Assert.assertNotNull(expected);
-    Assert.assertEquals(expected.getResponse().getStatus(), Response.Status.NOT_FOUND.getStatusCode());
+    Assertions.assertNotNull(expected);
+    Assertions.assertEquals(Response.Status.NOT_FOUND.getStatusCode(), expected.getResponse().getStatus());
     EasyMock.verify(containerRequest);
     EasyMock.verify(supervisorManager);
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/TaskResourceFilterTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/TaskResourceFilterTest.java
index 8a7684b5ccd..9cac97d6486 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/TaskResourceFilterTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/http/security/TaskResourceFilterTest.java
@@ -25,9 +25,9 @@ import org.apache.druid.indexing.overlord.TaskQueryTool;
 import org.apache.druid.indexing.overlord.supervisor.SupervisorSpec;
 import org.apache.druid.server.security.AuthorizerMapper;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import javax.ws.rs.WebApplicationException;
 import javax.ws.rs.core.MultivaluedMap;
@@ -46,7 +46,7 @@ public class TaskResourceFilterTest
   private ContainerRequest containerRequest;
   private TaskResourceFilter resourceFilter;
 
-  @Before
+  @BeforeEach
   public void setup()
   {
     authorizerMapper = EasyMock.createMock(AuthorizerMapper.class);
@@ -81,8 +81,8 @@ public class TaskResourceFilterTest
     catch (WebApplicationException e) {
       expected = e;
     }
-    Assert.assertNotNull(expected);
-    Assert.assertEquals(expected.getResponse().getStatus(), Response.Status.NOT_FOUND.getStatusCode());
+    Assertions.assertNotNull(expected);
+    Assertions.assertEquals(Response.Status.NOT_FOUND.getStatusCode(), expected.getResponse().getStatus());
     EasyMock.verify(containerRequest);
     EasyMock.verify(taskQueryTool);
   }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/CsvInputSourceSamplerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/CsvInputSourceSamplerTest.java
index d21e43ade17..dba1ae6c83f 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/CsvInputSourceSamplerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/CsvInputSourceSamplerTest.java
@@ -35,8 +35,8 @@ import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.indexing.DataSchema;
 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.util.List;
 
@@ -71,10 +71,10 @@ public class CsvInputSourceSamplerTest extends InitializedNullHandlingTest
         null
     );
 
-    Assert.assertEquals(4, response.getNumRowsRead());
-    Assert.assertEquals(4, response.getNumRowsIndexed());
-    Assert.assertEquals(4, response.getData().size());
-    Assert.assertEquals(
+    Assertions.assertEquals(4, response.getNumRowsRead());
+    Assertions.assertEquals(4, response.getNumRowsIndexed());
+    Assertions.assertEquals(4, response.getData().size());
+    Assertions.assertEquals(
         ImmutableList.of(
             new StringDimensionSchema("FirstName"),
             new StringDimensionSchema("LastName"),
@@ -83,7 +83,7 @@ public class CsvInputSourceSamplerTest extends InitializedNullHandlingTest
         ),
         response.getLogicalDimensions()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .add("__time", ColumnType.LONG)
                     .add("FirstName", ColumnType.STRING)
@@ -96,7 +96,7 @@ public class CsvInputSourceSamplerTest extends InitializedNullHandlingTest
 
     List<SamplerResponseRow> data = response.getData();
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new SamplerResponseRow(
             new SamplerTestUtils.MapAllowingNullValuesBuilder<String, Object>()
                 .put("Number", null)
@@ -116,7 +116,7 @@ public class CsvInputSourceSamplerTest extends InitializedNullHandlingTest
         ),
         data.get(0)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new SamplerResponseRow(
             new SamplerTestUtils.MapAllowingNullValuesBuilder<String, Object>()
                 .put("Number", null)
@@ -136,7 +136,7 @@ public class CsvInputSourceSamplerTest extends InitializedNullHandlingTest
         ),
         data.get(1)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new SamplerResponseRow(
             new SamplerTestUtils.MapAllowingNullValuesBuilder<String, Object>()
                 .put("Number", null)
@@ -156,7 +156,7 @@ public class CsvInputSourceSamplerTest extends InitializedNullHandlingTest
         ),
         data.get(2)
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         new SamplerResponseRow(
             new SamplerTestUtils.MapAllowingNullValuesBuilder<String, Object>()
                 .put("Number", null)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/IndexTaskSamplerSpecTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/IndexTaskSamplerSpecTest.java
index 36dfd966e8d..d0b07d8d803 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/IndexTaskSamplerSpecTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/IndexTaskSamplerSpecTest.java
@@ -37,10 +37,8 @@ import org.apache.druid.server.security.ResourceType;
 import org.easymock.Capture;
 import org.easymock.EasyMock;
 import org.easymock.EasyMockSupport;
-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.Test;
 
 import java.io.File;
 import java.io.IOException;
@@ -52,9 +50,6 @@ public class IndexTaskSamplerSpecTest extends EasyMockSupport
 
   private final InputSourceSampler inputSourceSampler = createMock(InputSourceSampler.class);
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   public IndexTaskSamplerSpecTest()
   {
     MAPPER.setInjectableValues(
@@ -116,17 +111,17 @@ public class IndexTaskSamplerSpecTest extends EasyMockSupport
     verifyAll();
 
     InputSource inputSource = capturedInputSource.getValue();
-    Assert.assertEquals(new File("/tmp"), ((LocalInputSource) inputSource).getBaseDir());
-    Assert.assertEquals("wikiticker-2015-09-12-sampled.json", ((LocalInputSource) inputSource).getFilter());
+    Assertions.assertEquals(new File("/tmp"), ((LocalInputSource) inputSource).getBaseDir());
+    Assertions.assertEquals("wikiticker-2015-09-12-sampled.json", ((LocalInputSource) inputSource).getFilter());
 
     DataSchema dataSchema = capturedDataSchema.getValue();
-    Assert.assertEquals("sampler", dataSchema.getDataSource());
-    Assert.assertEquals(JsonInputFormat.class, capturedInputFormat.getValue().getClass());
+    Assertions.assertEquals("sampler", dataSchema.getDataSource());
+    Assertions.assertEquals(JsonInputFormat.class, capturedInputFormat.getValue().getClass());
 
     SamplerConfig samplerConfig = capturedSamplerConfig.getValue();
-    Assert.assertEquals(123, samplerConfig.getNumRows());
-    Assert.assertEquals(2345, samplerConfig.getTimeoutMs());
-    Assert.assertEquals(
+    Assertions.assertEquals(123, samplerConfig.getNumRows());
+    Assertions.assertEquals(2345, samplerConfig.getTimeoutMs());
+    Assertions.assertEquals(
         Collections.singleton(
             new ResourceAction(new Resource(
                 LocalInputSource.TYPE_KEY,
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerDiscoveryTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerDiscoveryTest.java
index 70f58e795cc..430701f967c 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerDiscoveryTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerDiscoveryTest.java
@@ -37,8 +37,8 @@ import org.apache.druid.segment.column.RowSignature;
 import org.apache.druid.segment.indexing.DataSchema;
 import org.apache.druid.testing.InitializedNullHandlingTest;
 import org.apache.logging.log4j.util.Strings;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
@@ -70,10 +70,10 @@ public class InputSourceSamplerDiscoveryTest extends InitializedNullHandlingTest
         null
     );
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
-    Assert.assertEquals(
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(
         ImmutableList.of(
             new StringDimensionSchema("string"),
             new LongDimensionSchema("long"),
@@ -86,7 +86,7 @@ public class InputSourceSamplerDiscoveryTest extends InitializedNullHandlingTest
         response.getLogicalDimensions()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             AutoTypeColumnSchema.of("string"),
             AutoTypeColumnSchema.of("long"),
@@ -98,7 +98,7 @@ public class InputSourceSamplerDiscoveryTest extends InitializedNullHandlingTest
         ),
         response.getPhysicalDimensions()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .addTimeColumn()
                     .add("string", ColumnType.STRING)
@@ -130,10 +130,10 @@ public class InputSourceSamplerDiscoveryTest extends InitializedNullHandlingTest
         null
     );
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
-    Assert.assertEquals(
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(
         ImmutableList.of(
             new StringDimensionSchema("string"),
             new StringDimensionSchema("long"),
@@ -145,7 +145,7 @@ public class InputSourceSamplerDiscoveryTest extends InitializedNullHandlingTest
         response.getLogicalDimensions()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         ImmutableList.of(
             new StringDimensionSchema("string"),
             new StringDimensionSchema("long"),
@@ -156,7 +156,7 @@ public class InputSourceSamplerDiscoveryTest extends InitializedNullHandlingTest
         ),
         response.getPhysicalDimensions()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .addTimeColumn()
                     .add("string", ColumnType.STRING)
@@ -195,19 +195,19 @@ public class InputSourceSamplerDiscoveryTest extends InitializedNullHandlingTest
         null
     );
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
-    Assert.assertEquals(
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(
         dataSchema.getDimensionsSpec().getDimensions(),
         response.getLogicalDimensions()
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         dataSchema.getDimensionsSpec().getDimensions(),
         response.getPhysicalDimensions()
     );
-    Assert.assertEquals(
+    Assertions.assertEquals(
         RowSignature.builder()
                     .addTimeColumn()
                     .add("string", ColumnType.STRING)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerTest.java
index 77aab1da848..23f2a816673 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/InputSourceSamplerTest.java
@@ -59,13 +59,11 @@ import org.apache.druid.segment.indexing.DataSchema;
 import org.apache.druid.segment.transform.ExpressionTransform;
 import org.apache.druid.segment.transform.TransformSpec;
 import org.apache.druid.testing.InitializedNullHandlingTest;
-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.runners.Parameterized;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -81,7 +79,8 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass(name = "parserType = {0}")
+@MethodSource("constructorFeeder")
 public class InputSourceSamplerTest extends InitializedNullHandlingTest
 {
   private enum ParserType
@@ -114,10 +113,6 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
   private InputSourceSampler inputSourceSampler;
   private ParserType parserType;
 
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
-  @Parameterized.Parameters(name = "parserType = {0}")
   public static Iterable<Object[]> constructorFeeder()
   {
     OBJECT_MAPPER.registerModules(new SamplerModule().getJacksonModules());
@@ -132,7 +127,7 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
     this.parserType = parserType;
   }
 
-  @Before
+  @BeforeEach
   public void setupTest()
   {
     inputSourceSampler = new InputSourceSampler(OBJECT_MAPPER);
@@ -156,10 +151,11 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
   @Test
   public void testNoParams()
   {
-    expectedException.expect(NullPointerException.class);
-    expectedException.expectMessage("inputSource required");
-
-    inputSourceSampler.sample(null, null, null, null);
+    final NullPointerException exception = Assertions.assertThrows(
+        NullPointerException.class,
+        () -> inputSourceSampler.sample(null, null, null, null)
+    );
+    Assertions.assertEquals("inputSource required", exception.getMessage());
   }
 
   @Test
@@ -168,9 +164,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
     final InputSource inputSource = createInputSource(getTestRows());
     final SamplerResponse response = inputSourceSampler.sample(inputSource, createInputFormat(), null, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(0, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(0, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -241,9 +237,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
         new SamplerConfig(3, null, null, null)
     );
 
-    Assert.assertEquals(3, response.getNumRowsRead());
-    Assert.assertEquals(0, response.getNumRowsIndexed());
-    Assert.assertEquals(3, response.getData().size());
+    Assertions.assertEquals(3, response.getNumRowsRead());
+    Assertions.assertEquals(0, response.getNumRowsIndexed());
+    Assertions.assertEquals(3, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -287,9 +283,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(6, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(6, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -396,9 +392,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -496,9 +492,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -602,9 +598,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(6, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(6, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -713,9 +709,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(4, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(4, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -796,9 +792,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(3, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(3, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -867,9 +863,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(4, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(4, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -956,9 +952,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(6, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(3, response.getData().size());
+    Assertions.assertEquals(6, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(3, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -1024,9 +1020,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(5, response.getNumRowsRead());
-    Assert.assertEquals(4, response.getNumRowsIndexed());
-    Assert.assertEquals(3, response.getData().size());
+    Assertions.assertEquals(5, response.getNumRowsRead());
+    Assertions.assertEquals(4, response.getNumRowsIndexed());
+    Assertions.assertEquals(3, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -1111,9 +1107,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
     SamplerResponse response = inputSourceSampler.sample(inputSource, inputFormat, dataSchema, null);
 
-    Assert.assertEquals(7, response.getNumRowsRead());
-    Assert.assertEquals(5, response.getNumRowsIndexed());
-    Assert.assertEquals(4, response.getData().size());
+    Assertions.assertEquals(7, response.getNumRowsRead());
+    Assertions.assertEquals(5, response.getNumRowsIndexed());
+    Assertions.assertEquals(4, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
 
@@ -1232,9 +1228,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
     //
     int illegalRows = STR_JSON_ROWS.size();
     int legalRows = STR_JSON_ROWS.size() - 1;
-    Assert.assertEquals(illegalRows + legalRows, response.getNumRowsRead());
-    Assert.assertEquals(legalRows, response.getNumRowsIndexed());
-    Assert.assertEquals(illegalRows + 2, response.getData().size());
+    Assertions.assertEquals(illegalRows + legalRows, response.getNumRowsRead());
+    Assertions.assertEquals(legalRows, response.getNumRowsIndexed());
+    Assertions.assertEquals(illegalRows + 2, response.getData().size());
 
     List<SamplerResponseRow> data = response.getData();
     List<Map<String, Object>> rawColumnList = this.getRawColumns();
@@ -1289,7 +1285,7 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
     );
   }
 
-  @Test(expected = SamplerException.class)
+  @Test
   public void testReaderCreationException()
   {
     InputSource failingReaderInputSource = new InputSource()
@@ -1316,7 +1312,10 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
         throw new RuntimeException();
       }
     };
-    inputSourceSampler.sample(failingReaderInputSource, null, null, null);
+    Assertions.assertThrows(
+        SamplerException.class,
+        () -> inputSourceSampler.sample(failingReaderInputSource, null, null, null)
+    );
   }
 
   @Test
@@ -1348,9 +1347,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
         new SamplerConfig(4, null, null, null)
     );
 
-    Assert.assertEquals(4, response.getNumRowsRead());
-    Assert.assertEquals(4, response.getNumRowsIndexed());
-    Assert.assertEquals(2, response.getData().size());
+    Assertions.assertEquals(4, response.getNumRowsRead());
+    Assertions.assertEquals(4, response.getNumRowsIndexed());
+    Assertions.assertEquals(2, response.getData().size());
 
   }
 
@@ -1383,9 +1382,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
         new SamplerConfig(null, null, HumanReadableBytes.valueOf(256), null)
     );
 
-    Assert.assertEquals(4, response.getNumRowsRead());
-    Assert.assertEquals(4, response.getNumRowsIndexed());
-    Assert.assertEquals(2, response.getData().size());
+    Assertions.assertEquals(4, response.getNumRowsRead());
+    Assertions.assertEquals(4, response.getNumRowsIndexed());
+    Assertions.assertEquals(2, response.getData().size());
   }
 
   @Test
@@ -1417,9 +1416,9 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
         new SamplerConfig(null, null, null, HumanReadableBytes.valueOf(300))
     );
 
-    Assert.assertEquals(4, response.getNumRowsRead());
-    Assert.assertEquals(4, response.getNumRowsIndexed());
-    Assert.assertEquals(2, response.getData().size());
+    Assertions.assertEquals(4, response.getNumRowsRead());
+    Assertions.assertEquals(4, response.getNumRowsIndexed());
+    Assertions.assertEquals(2, response.getData().size());
   }
 
   private List<String> getTestRows()
@@ -1507,10 +1506,10 @@ public class InputSourceSamplerTest extends InitializedNullHandlingTest
 
   private static void assertEqualsSamplerResponseRow(SamplerResponseRow row1, SamplerResponseRow row2)
   {
-    Assert.assertTrue(equalsIgnoringType(row1.getInput(), row2.getInput()));
-    Assert.assertEquals(row1.getParsed(), row2.getParsed());
-    Assert.assertEquals(row1.getError(), row2.getError());
-    Assert.assertEquals(row1.isUnparseable(), row2.isUnparseable());
+    Assertions.assertTrue(equalsIgnoringType(row1.getInput(), row2.getInput()));
+    Assertions.assertEquals(row1.getParsed(), row2.getParsed());
+    Assertions.assertEquals(row1.getError(), row2.getError());
+    Assertions.assertEquals(row1.isUnparseable(), row2.isUnparseable());
   }
 
   private static boolean equalsIgnoringType(Map<String, Object> map1, Map<String, Object> map2)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResourceTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResourceTest.java
index 5566d7dd670..7ba5423ec43 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResourceTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResourceTest.java
@@ -32,9 +32,9 @@ import org.apache.druid.server.security.Resource;
 import org.apache.druid.server.security.ResourceAction;
 import org.apache.druid.server.security.ResourceType;
 import org.easymock.EasyMock;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import javax.servlet.http.HttpServletRequest;
 import java.util.Collections;
@@ -78,7 +78,7 @@ public class SamplerResourceTest
     }
   };
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     req = EasyMock.createStrictMock(HttpServletRequest.class);
@@ -125,7 +125,7 @@ public class SamplerResourceTest
         samplerSpec
     );
 
-    Assert.assertThrows(ForbiddenException.class, () -> samplerResource.post(samplerSpec, req));
+    Assertions.assertThrows(ForbiddenException.class, () -> samplerResource.post(samplerSpec, req));
   }
 
   @Test
@@ -174,7 +174,7 @@ public class SamplerResourceTest
         samplerSpec
     );
 
-    Assert.assertThrows(UOE.class, () -> samplerResource.post(samplerSpec, req));
+    Assertions.assertThrows(UOE.class, () -> samplerResource.post(samplerSpec, req));
   }
 
   private void expectAuthorizationTokenCheck(String username)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResponseTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResponseTest.java
index f3329a9c523..43aea0eb3a8 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResponseTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/sampler/SamplerResponseTest.java
@@ -28,8 +28,8 @@ import org.apache.druid.segment.AutoTypeColumnSchema;
 import org.apache.druid.segment.TestHelper;
 import org.apache.druid.segment.column.ColumnType;
 import org.apache.druid.segment.column.RowSignature;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.util.List;
@@ -73,6 +73,6 @@ public class SamplerResponseTest
     );
     String expected = "{\"numRowsRead\":1123,\"numRowsIndexed\":1112,\"logicalDimensions\":[{\"type\":\"string\",\"name\":\"dim1\",\"multiValueHandling\":\"SORTED_ARRAY\",\"createBitmapIndex\":true}],\"physicalDimensions\":[{\"type\":\"auto\",\"name\":\"dim1\",\"multiValueHandling\":\"SORTED_ARRAY\",\"createBitmapIndex\":true}],\"logicalSegmentSchema\":[{\"name\":\"__time\",\"type\":\"LONG\"},{\"name\":\"dim1\",\"type\":\"STRING\"},{\"name\":\"met1\",\"type\":\"LONG\"}],\"data\":[{\"inpu [...]
 
-    Assert.assertEquals(expected, out);
+    Assertions.assertEquals(expected, out);
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java
index 3450aa8d480..12724ca8d37 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithAffinityWorkerSelectStrategyTest.java
@@ -29,8 +29,8 @@ import org.apache.druid.indexing.worker.Worker;
 import org.apache.druid.indexing.worker.config.WorkerConfig;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.segment.TestHelper;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashMap;
 import java.util.HashSet;
@@ -82,7 +82,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
             ),
             noopTask
     );
-    Assert.assertEquals("localhost1", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost1", worker.getWorker().getHost());
   }
 
   @Test
@@ -113,7 +113,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
             ),
             NoopTask.create()
     );
-    Assert.assertEquals("lhost", worker.getWorker().getHost());
+    Assertions.assertEquals("lhost", worker.getWorker().getHost());
   }
 
   @Test
@@ -137,7 +137,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
             ),
             NoopTask.create()
     );
-    Assert.assertNull(worker);
+    Assertions.assertNull(worker);
   }
 
   @Test
@@ -152,7 +152,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
         objectMapper.writeValueAsBytes(strategy),
         WorkerSelectStrategy.class
     );
-    Assert.assertEquals(strategy, strategy2);
+    Assertions.assertEquals(strategy, strategy2);
   }
 
   @Test
@@ -191,7 +191,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
         ),
         noopTask
     );
-    Assert.assertNotNull(worker);
+    Assertions.assertNotNull(worker);
 
     ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
@@ -218,7 +218,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
         noopTask
     );
 
-    Assert.assertNull(worker1);
+    Assertions.assertNull(worker1);
 
   }
 
@@ -258,7 +258,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
         ),
         noopTask
     );
-    Assert.assertNotNull(worker);
+    Assertions.assertNotNull(worker);
 
     ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
@@ -285,7 +285,7 @@ public class EqualDistributionWithAffinityWorkerSelectStrategyTest
         noopTask
     );
 
-    Assert.assertNull(worker1);
+    Assertions.assertNull(worker1);
 
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java
index 442a64ae068..40c3fc689c6 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWithCategorySpecWorkerSelectStrategyTest.java
@@ -34,8 +34,8 @@ import org.apache.druid.indexing.worker.Worker;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.granularity.AllGranularity;
 import org.apache.druid.segment.indexing.DataSchema;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 import javax.annotation.Nullable;
@@ -80,7 +80,7 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
   public void testFindWorkerForTaskWithNullWorkerTierSpec()
   {
     ImmutableWorkerInfo worker = selectWorker(null);
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -100,7 +100,7 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker1 = selectWorker(workerCategorySpec1);
-    Assert.assertEquals("localhost3", worker1.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker1.getWorker().getHost());
 
     // test defaultTier == null and tierAffinity is not empty
     final WorkerCategorySpec workerCategorySpec2 = new WorkerCategorySpec(
@@ -116,7 +116,7 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker2 = selectWorker(workerCategorySpec2);
-    Assert.assertEquals("localhost3", worker2.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker2.getWorker().getHost());
 
     // test defaultTier != null and tierAffinity is empty
     final WorkerCategorySpec workerCategorySpec3 = new WorkerCategorySpec(
@@ -132,7 +132,7 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker3 = selectWorker(workerCategorySpec3);
-    Assert.assertEquals("localhost3", worker3.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker3.getWorker().getHost());
   }
 
   @Test
@@ -151,7 +151,7 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker = selectWorker(workerCategorySpec);
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -170,7 +170,7 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker = selectWorker(workerCategorySpec);
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -189,7 +189,7 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker = selectWorker(workerCategorySpec);
-    Assert.assertNull(worker);
+    Assertions.assertNull(worker);
   }
 
   @Test
@@ -216,9 +216,9 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
         WORKERS_FOR_TIER_TESTS,
         taskWithSupervisor
     );
-    Assert.assertNotNull(worker);
-    Assert.assertEquals("c2", worker.getWorker().getCategory());
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertNotNull(worker);
+    Assertions.assertEquals("c2", worker.getWorker().getCategory());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -245,9 +245,9 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
         WORKERS_FOR_TIER_TESTS,
         taskWithSupervisor
     );
-    Assert.assertNotNull(worker);
-    Assert.assertEquals("c1", worker.getWorker().getCategory());
-    Assert.assertEquals("localhost1", worker.getWorker().getHost());
+    Assertions.assertNotNull(worker);
+    Assertions.assertEquals("c1", worker.getWorker().getCategory());
+    Assertions.assertEquals("localhost1", worker.getWorker().getHost());
   }
 
   @Test
@@ -275,9 +275,9 @@ public class EqualDistributionWithCategorySpecWorkerSelectStrategyTest
         WORKERS_FOR_TIER_TESTS,
         taskWithSupervisor
     );
-    Assert.assertNotNull(worker);
-    Assert.assertEquals("c2", worker.getWorker().getCategory());
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertNotNull(worker);
+    Assertions.assertEquals("c2", worker.getWorker().getCategory());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   private ImmutableWorkerInfo selectWorker(WorkerCategorySpec workerCategorySpec)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java
index 2568217042b..a1675b94be7 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/EqualDistributionWorkerSelectStrategyTest.java
@@ -27,8 +27,8 @@ import org.apache.druid.indexing.overlord.config.HttpRemoteTaskRunnerConfig;
 import org.apache.druid.indexing.worker.Worker;
 import org.apache.druid.indexing.worker.config.WorkerConfig;
 import org.apache.druid.java.util.common.DateTimes;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashSet;
 
@@ -91,7 +91,7 @@ public class EqualDistributionWorkerSelectStrategyTest
         ),
         NoopTask.forDatasource("foo")
     );
-    Assert.assertEquals("lhost", worker.getWorker().getHost());
+    Assertions.assertEquals("lhost", worker.getWorker().getHost());
   }
 
   @Test
@@ -119,7 +119,7 @@ public class EqualDistributionWorkerSelectStrategyTest
         ),
         NoopTask.forDatasource("foo")
     );
-    Assert.assertEquals("localhost", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost", worker.getWorker().getHost());
   }
 
   @Test
@@ -147,7 +147,7 @@ public class EqualDistributionWorkerSelectStrategyTest
         ),
         NoopTask.forDatasource("foo")
     );
-    Assert.assertEquals("enableHost", worker.getWorker().getHost());
+    Assertions.assertEquals("enableHost", worker.getWorker().getHost());
   }
 
   @Test
@@ -175,7 +175,7 @@ public class EqualDistributionWorkerSelectStrategyTest
         ),
         NoopTask.forDatasource("foo")
     );
-    Assert.assertEquals("enableHost", worker.getWorker().getHost());
+    Assertions.assertEquals("enableHost", worker.getWorker().getHost());
   }
 
   @Test
@@ -197,7 +197,7 @@ public class EqualDistributionWorkerSelectStrategyTest
         WORKERS_FOR_AFFINITY_TESTS,
         createDummyTask("foo")
     );
-    Assert.assertEquals("localhost1", workerFoo.getWorker().getHost());
+    Assertions.assertEquals("localhost1", workerFoo.getWorker().getHost());
 
     // With weak affinity, bar (which has no affinity workers available) can use a non-affinity worker.
     ImmutableWorkerInfo workerBar = strategy.findWorkerForTask(
@@ -205,14 +205,14 @@ public class EqualDistributionWorkerSelectStrategyTest
         WORKERS_FOR_AFFINITY_TESTS,
         createDummyTask("bar")
     );
-    Assert.assertEquals("localhost0", workerBar.getWorker().getHost());
+    Assertions.assertEquals("localhost0", workerBar.getWorker().getHost());
 
     ImmutableWorkerInfo workerBaz = strategy.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
         WORKERS_FOR_AFFINITY_TESTS,
         createDummyTask("baz")
     );
-    Assert.assertEquals("localhost0", workerBaz.getWorker().getHost());
+    Assertions.assertEquals("localhost0", workerBaz.getWorker().getHost());
   }
 
   @Test
@@ -234,7 +234,7 @@ public class EqualDistributionWorkerSelectStrategyTest
         WORKERS_FOR_AFFINITY_TESTS,
         createDummyTask("foo")
     );
-    Assert.assertEquals("localhost1", workerFoo.getWorker().getHost());
+    Assertions.assertEquals("localhost1", workerFoo.getWorker().getHost());
 
     // With strong affinity, no workers can be found for bar.
     ImmutableWorkerInfo workerBar = strategy.findWorkerForTask(
@@ -242,14 +242,14 @@ public class EqualDistributionWorkerSelectStrategyTest
         WORKERS_FOR_AFFINITY_TESTS,
         createDummyTask("bar")
     );
-    Assert.assertNull(workerBar);
+    Assertions.assertNull(workerBar);
 
     ImmutableWorkerInfo workerBaz = strategy.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
         WORKERS_FOR_AFFINITY_TESTS,
         createDummyTask("baz")
     );
-    Assert.assertEquals("localhost0", workerBaz.getWorker().getHost());
+    Assertions.assertEquals("localhost0", workerBaz.getWorker().getHost());
   }
 
   private static NoopTask createDummyTask(final String dataSource)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java
index 0455e394937..be03249697b 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithAffinityWorkerSelectStrategyTest.java
@@ -27,8 +27,8 @@ import org.apache.druid.indexing.overlord.config.HttpRemoteTaskRunnerConfig;
 import org.apache.druid.indexing.worker.Worker;
 import org.apache.druid.indexing.worker.config.WorkerConfig;
 import org.apache.druid.java.util.common.DateTimes;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashMap;
 import java.util.HashSet;
@@ -64,7 +64,7 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
         ),
         NoopTask.forDatasource("foo")
     );
-    Assert.assertEquals("localhost", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost", worker.getWorker().getHost());
   }
 
   @Test
@@ -95,7 +95,7 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
         ),
         NoopTask.create()
     );
-    Assert.assertEquals("lhost", worker.getWorker().getHost());
+    Assertions.assertEquals("lhost", worker.getWorker().getHost());
   }
 
   @Test
@@ -119,7 +119,7 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
         ),
         NoopTask.create()
     );
-    Assert.assertNull(worker);
+    Assertions.assertNull(worker);
   }
 
   @Test
@@ -158,7 +158,7 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
         ),
         noopTask
     );
-    Assert.assertNotNull(worker);
+    Assertions.assertNotNull(worker);
 
     ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
@@ -185,7 +185,7 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
         noopTask
     );
 
-    Assert.assertNull(worker1);
+    Assertions.assertNull(worker1);
 
   }
 
@@ -225,7 +225,7 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
         ),
         noopTask
     );
-    Assert.assertNotNull(worker);
+    Assertions.assertNotNull(worker);
 
     ImmutableWorkerInfo worker1 = strategy.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
@@ -252,7 +252,7 @@ public class FillCapacityWithAffinityWorkerSelectStrategyTest
         noopTask
     );
 
-    Assert.assertNull(worker1);
+    Assertions.assertNull(worker1);
 
   }
 }
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java
index a63dde25b25..48bd3e6939a 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/FillCapacityWithCategorySpecWorkerSelectStrategyTest.java
@@ -34,8 +34,8 @@ import org.apache.druid.indexing.worker.Worker;
 import org.apache.druid.java.util.common.DateTimes;
 import org.apache.druid.java.util.common.granularity.AllGranularity;
 import org.apache.druid.segment.indexing.DataSchema;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
 import javax.annotation.Nullable;
@@ -80,7 +80,7 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
   public void testFindWorkerForTaskWithNullWorkerTierSpec()
   {
     ImmutableWorkerInfo worker = selectWorker(null);
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -100,7 +100,7 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker1 = selectWorker(workerCategorySpec1);
-    Assert.assertEquals("localhost1", worker1.getWorker().getHost());
+    Assertions.assertEquals("localhost1", worker1.getWorker().getHost());
 
     // test defaultTier == null and tierAffinity is not empty
     final WorkerCategorySpec workerCategorySpec2 = new WorkerCategorySpec(
@@ -116,7 +116,7 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker2 = selectWorker(workerCategorySpec2);
-    Assert.assertEquals("localhost1", worker2.getWorker().getHost());
+    Assertions.assertEquals("localhost1", worker2.getWorker().getHost());
 
     // test defaultTier != null and tierAffinity is empty
     final WorkerCategorySpec workerCategorySpec3 = new WorkerCategorySpec(
@@ -132,7 +132,7 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker3 = selectWorker(workerCategorySpec3);
-    Assert.assertEquals("localhost1", worker3.getWorker().getHost());
+    Assertions.assertEquals("localhost1", worker3.getWorker().getHost());
   }
 
   @Test
@@ -151,7 +151,7 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker = selectWorker(workerCategorySpec);
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -170,7 +170,7 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker = selectWorker(workerCategorySpec);
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -189,7 +189,7 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
     );
 
     ImmutableWorkerInfo worker = selectWorker(workerCategorySpec);
-    Assert.assertNull(worker);
+    Assertions.assertNull(worker);
   }
 
   @Test
@@ -218,9 +218,9 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
         WORKERS_FOR_TIER_TESTS,
         taskWithSupervisor
     );
-    Assert.assertNotNull(worker);
-    Assert.assertEquals("c2", worker.getWorker().getCategory());
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertNotNull(worker);
+    Assertions.assertEquals("c2", worker.getWorker().getCategory());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   @Test
@@ -249,9 +249,9 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
         WORKERS_FOR_TIER_TESTS,
         taskWithSupervisor
     );
-    Assert.assertNotNull(worker);
-    Assert.assertEquals("c1", worker.getWorker().getCategory());
-    Assert.assertEquals("localhost1", worker.getWorker().getHost());
+    Assertions.assertNotNull(worker);
+    Assertions.assertEquals("c1", worker.getWorker().getCategory());
+    Assertions.assertEquals("localhost1", worker.getWorker().getHost());
   }
 
   @Test
@@ -280,9 +280,9 @@ public class FillCapacityWithCategorySpecWorkerSelectStrategyTest
         WORKERS_FOR_TIER_TESTS,
         taskWithSupervisor
     );
-    Assert.assertNotNull(worker);
-    Assert.assertEquals("c2", worker.getWorker().getCategory());
-    Assert.assertEquals("localhost3", worker.getWorker().getHost());
+    Assertions.assertNotNull(worker);
+    Assertions.assertEquals("c2", worker.getWorker().getCategory());
+    Assertions.assertEquals("localhost3", worker.getWorker().getHost());
   }
 
   private ImmutableWorkerInfo selectWorker(WorkerCategorySpec workerCategorySpec)
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/JavaScriptWorkerSelectStrategyTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/JavaScriptWorkerSelectStrategyTest.java
index fb01549951a..617ca05f3ea 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/JavaScriptWorkerSelectStrategyTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/JavaScriptWorkerSelectStrategyTest.java
@@ -29,17 +29,11 @@ import org.apache.druid.indexing.overlord.config.HttpRemoteTaskRunnerConfig;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.apache.druid.js.JavaScriptConfig;
 import org.easymock.EasyMock;
-import org.hamcrest.CoreMatchers;
-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.Test;
 
 public class JavaScriptWorkerSelectStrategyTest
 {
-  @Rule
-  public ExpectedException expectedException = ExpectedException.none();
-
   private final JavaScriptWorkerSelectStrategy STRATEGY = new JavaScriptWorkerSelectStrategy(
       "function (config, zkWorkers, task) {\n"
       + "var batch_workers = new java.util.ArrayList();\n"
@@ -82,7 +76,7 @@ public class JavaScriptWorkerSelectStrategyTest
         )
     );
 
-    Assert.assertEquals(
+    Assertions.assertEquals(
         STRATEGY,
         mapper.readValue(
             mapper.writeValueAsString(STRATEGY),
@@ -104,11 +98,12 @@ public class JavaScriptWorkerSelectStrategyTest
 
     final String strategyString = mapper.writeValueAsString(STRATEGY);
 
-    expectedException.expect(JsonMappingException.class);
-    expectedException.expectCause(CoreMatchers.instanceOf(IllegalStateException.class));
-    expectedException.expectMessage("JavaScript is disabled");
-
-    mapper.readValue(strategyString, WorkerSelectStrategy.class);
+    final JsonMappingException exception = Assertions.assertThrows(
+        JsonMappingException.class,
+        () -> mapper.readValue(strategyString, WorkerSelectStrategy.class)
+    );
+    Assertions.assertInstanceOf(IllegalStateException.class, exception.getCause());
+    Assertions.assertTrue(exception.getMessage().contains("JavaScript is disabled"));
   }
 
   @Test
@@ -127,7 +122,7 @@ public class JavaScriptWorkerSelectStrategyTest
         createMockTask("index_parallel")
     );
     // batch tasks should be sent to worker1
-    Assert.assertEquals(worker1, workerForBatchTask);
+    Assertions.assertEquals(worker1, workerForBatchTask);
 
     ImmutableWorkerInfo workerForOtherTask = STRATEGY.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
@@ -135,7 +130,7 @@ public class JavaScriptWorkerSelectStrategyTest
         createMockTask("other_type")
     );
     // all other tasks should be sent to worker2
-    Assert.assertEquals(worker2, workerForOtherTask);
+    Assertions.assertEquals(worker2, workerForOtherTask);
   }
 
   @Test
@@ -150,7 +145,7 @@ public class JavaScriptWorkerSelectStrategyTest
         workerMap,
         createMockTask("other_type")
     );
-    Assert.assertNull(workerForOtherTask);
+    Assertions.assertNull(workerForOtherTask);
   }
 
   @Test
@@ -165,7 +160,7 @@ public class JavaScriptWorkerSelectStrategyTest
         workerMap,
         createMockTask("index_parallel")
     );
-    Assert.assertNull(workerForBatchTask);
+    Assertions.assertNull(workerForBatchTask);
 
     ImmutableWorkerInfo workerForOtherTask = STRATEGY.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
@@ -173,7 +168,7 @@ public class JavaScriptWorkerSelectStrategyTest
         createMockTask("otherTask")
     );
     // all other tasks should be sent to worker2
-    Assert.assertNull(workerForOtherTask);
+    Assertions.assertNull(workerForOtherTask);
   }
 
   @Test
@@ -188,7 +183,7 @@ public class JavaScriptWorkerSelectStrategyTest
         workerMap,
         createMockTask("index_parallel")
     );
-    Assert.assertNull(workerForBatchTask);
+    Assertions.assertNull(workerForBatchTask);
 
     ImmutableWorkerInfo workerForOtherTask = STRATEGY.findWorkerForTask(
         new HttpRemoteTaskRunnerConfig(),
@@ -196,7 +191,7 @@ public class JavaScriptWorkerSelectStrategyTest
         createMockTask("otherTask")
     );
     // all other tasks should be sent to worker2
-    Assert.assertNull(workerForOtherTask);
+    Assertions.assertNull(workerForOtherTask);
   }
 
   @Test
@@ -212,7 +207,7 @@ public class JavaScriptWorkerSelectStrategyTest
         workerMap,
         createMockTask("index_parallel")
     );
-    Assert.assertEquals(workerMap.get("10.0.0.2"), workerForBatchTask);
+    Assertions.assertEquals(workerMap.get("10.0.0.2"), workerForBatchTask);
 
   }
 
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerCategorySpecTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerCategorySpecTest.java
index 9576aa0ffbb..9adac706983 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerCategorySpecTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/setup/WorkerCategorySpecTest.java
@@ -22,15 +22,15 @@ package org.apache.druid.indexing.overlord.setup;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.collect.ImmutableMap;
 import org.apache.druid.jackson.DefaultObjectMapper;
-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;
 
 public class WorkerCategorySpecTest
 {
   private ObjectMapper mapper;
 
-  @Before
+  @BeforeEach
   public void setUp()
   {
     mapper = new DefaultObjectMapper();
@@ -55,8 +55,8 @@ public class WorkerCategorySpecTest
         ), WorkerCategorySpec.class
     );
 
-    Assert.assertTrue(workerCategorySpec.isStrong());
-    Assert.assertEquals(ImmutableMap.of(
+    Assertions.assertTrue(workerCategorySpec.isStrong());
+    Assertions.assertEquals(ImmutableMap.of(
         "index_kafka",
         new WorkerCategorySpec.CategoryConfig("c1", ImmutableMap.of("ds1", "c2"), null)
     ), workerCategorySpec.getCategoryMap());
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/NoticesQueueTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/NoticesQueueTest.java
index 7cc3c07ed90..3e4914a09b9 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/NoticesQueueTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/NoticesQueueTest.java
@@ -21,8 +21,8 @@ package org.apache.druid.indexing.overlord.supervisor;
 
 import org.apache.druid.indexing.seekablestream.supervisor.NoticesQueue;
 import org.apache.druid.java.util.common.concurrent.Execs;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -36,27 +36,27 @@ public class NoticesQueueTest
     final NoticesQueue<String> queue = new NoticesQueue<>();
 
     for (int i = 0; i < 3; i++) {
-      Assert.assertEquals(0, queue.size());
+      Assertions.assertEquals(0, queue.size());
       queue.add("xyz");
-      Assert.assertEquals(1, queue.size());
+      Assertions.assertEquals(1, queue.size());
 
       queue.add("xyz");
-      Assert.assertEquals(1, queue.size());
+      Assertions.assertEquals(1, queue.size());
 
       queue.add("foo");
-      Assert.assertEquals(2, queue.size());
+      Assertions.assertEquals(2, queue.size());
 
       queue.add("xyz");
-      Assert.assertEquals(2, queue.size());
+      Assertions.assertEquals(2, queue.size());
 
       queue.add("bar");
-      Assert.assertEquals(3, queue.size());
+      Assertions.assertEquals(3, queue.size());
 
-      Assert.assertEquals("xyz", queue.poll(10));
-      Assert.assertEquals("foo", queue.poll(10));
-      Assert.assertEquals("bar", queue.poll(10));
-      Assert.assertNull(queue.poll(10));
-      Assert.assertEquals(0, queue.size());
+      Assertions.assertEquals("xyz", queue.poll(10));
+      Assertions.assertEquals("foo", queue.poll(10));
+      Assertions.assertEquals("bar", queue.poll(10));
+      Assertions.assertNull(queue.poll(10));
+      Assertions.assertEquals(0, queue.size());
     }
   }
 
@@ -72,7 +72,7 @@ public class NoticesQueueTest
       // Imperfect test: ideally we "add" after "poll", but we can't tell if "poll" has started yet.
       // Don't want to add a sleep, to avoid adding additional time to the test case, so we live with the imperfection.
       queue.add("xyz");
-      Assert.assertEquals("xyz", item.get());
+      Assertions.assertEquals("xyz", item.get());
     }
     finally {
       exec.shutdownNow();
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java
index 7ef1c85f565..bcc2e12e248 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/SupervisorManagerTest.java
@@ -32,7 +32,6 @@ import org.apache.druid.data.input.impl.ByteEntity;
 import org.apache.druid.data.input.impl.DimensionsSpec;
 import org.apache.druid.data.input.impl.TimestampSpec;
 import org.apache.druid.error.DruidException;
-import org.apache.druid.error.DruidExceptionMatcher;
 import org.apache.druid.error.InvalidInput;
 import org.apache.druid.indexing.common.TaskLockType;
 import org.apache.druid.indexing.common.task.Tasks;
@@ -59,16 +58,13 @@ import org.apache.druid.server.metrics.SupervisorStatsProvider;
 import org.apache.druid.timeline.partition.NumberedShardSpec;
 import org.easymock.Capture;
 import org.easymock.EasyMock;
-import org.easymock.EasyMockRunner;
+import org.easymock.EasyMockExtension;
 import org.easymock.EasyMockSupport;
 import org.easymock.Mock;
-import org.hamcrest.MatcherAssert;
-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.annotation.Nullable;
 import java.lang.reflect.Field;
@@ -79,7 +75,7 @@ import java.util.Map;
 import java.util.OptionalInt;
 import java.util.concurrent.ConcurrentHashMap;
 
-@RunWith(EasyMockRunner.class)
+@ExtendWith(EasyMockExtension.class)
 public class SupervisorManagerTest extends EasyMockSupport
 {
   private static final ObjectMapper MAPPER = new DefaultObjectMapper();
@@ -98,10 +94,7 @@ public class SupervisorManagerTest extends EasyMockSupport
 
   private SupervisorManager manager;
 
-  @Rule
-  public final ExpectedException exception = ExpectedException.none();
-
-  @Before
+  @BeforeEach
   public void setUp()
   {
     manager = new SupervisorManager(MAPPER, metadataSupervisorManager);
@@ -116,7 +109,7 @@ public class SupervisorManagerTest extends EasyMockSupport
         "id3", new TestSupervisorSpec("id3", supervisor3)
     );
 
-    Assert.assertTrue(manager.getSupervisorIds().isEmpty());
+    Assertions.assertTrue(manager.getSupervisorIds().isEmpty());
 
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(existingSpecs);
     metadataSupervisorManager.insert("id1", spec);
@@ -127,11 +120,11 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.start();
-    Assert.assertEquals(1, manager.getSupervisorIds().size());
+    Assertions.assertEquals(1, manager.getSupervisorIds().size());
 
     manager.createOrUpdateAndStartSupervisor(spec, false);
-    Assert.assertEquals(2, manager.getSupervisorIds().size());
-    Assert.assertEquals(spec, manager.getSupervisorSpec("id1").get());
+    Assertions.assertEquals(2, manager.getSupervisorIds().size());
+    Assertions.assertEquals(spec, manager.getSupervisorSpec("id1").get());
     verifyAll();
 
     resetAll();
@@ -141,8 +134,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.createOrUpdateAndStartSupervisor(spec2, false);
-    Assert.assertEquals(2, manager.getSupervisorIds().size());
-    Assert.assertEquals(spec2, manager.getSupervisorSpec("id1").get());
+    Assertions.assertEquals(2, manager.getSupervisorIds().size());
+    Assertions.assertEquals(spec2, manager.getSupervisorSpec("id1").get());
     verifyAll();
 
     resetAll();
@@ -151,9 +144,9 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     boolean retVal = manager.stopAndRemoveSupervisor("id1");
-    Assert.assertTrue(retVal);
-    Assert.assertEquals(1, manager.getSupervisorIds().size());
-    Assert.assertEquals(Optional.absent(), manager.getSupervisorSpec("id1"));
+    Assertions.assertTrue(retVal);
+    Assertions.assertEquals(1, manager.getSupervisorIds().size());
+    Assertions.assertEquals(Optional.absent(), manager.getSupervisorSpec("id1"));
     verifyAll();
 
     resetAll();
@@ -165,7 +158,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     manager.stop();
     verifyAll();
 
-    Assert.assertTrue(manager.getSupervisorIds().isEmpty());
+    Assertions.assertTrue(manager.getSupervisorIds().isEmpty());
   }
 
   @Test
@@ -181,7 +174,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     };
     SupervisorSpec spec2 = new TestSupervisorSpec("id1", supervisor2);
 
-    Assert.assertTrue(manager.getSupervisorIds().isEmpty());
+    Assertions.assertTrue(manager.getSupervisorIds().isEmpty());
 
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(ImmutableMap.of());
     metadataSupervisorManager.insert("id1", spec);
@@ -190,26 +183,30 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.start();
-    Assert.assertEquals(0, manager.getSupervisorIds().size());
+    Assertions.assertEquals(0, manager.getSupervisorIds().size());
 
     manager.createOrUpdateAndStartSupervisor(spec, false);
-    Assert.assertEquals(1, manager.getSupervisorIds().size());
-    Assert.assertEquals(spec, manager.getSupervisorSpec("id1").get());
+    Assertions.assertEquals(1, manager.getSupervisorIds().size());
+    Assertions.assertEquals(spec, manager.getSupervisorSpec("id1").get());
     verifyAll();
 
     resetAll();
-    exception.expect(DruidException.class);
     replayAll();
 
-    manager.createOrUpdateAndStartSupervisor(spec2, false);
+    Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.createOrUpdateAndStartSupervisor(spec2, false)
+    );
     verifyAll();
   }
 
   @Test
   public void testCreateOrUpdateAndStartSupervisorNotStarted()
   {
-    exception.expect(IllegalStateException.class);
-    manager.createOrUpdateAndStartSupervisor(new TestSupervisorSpec("id", null), false);
+    Assertions.assertThrows(
+        IllegalStateException.class,
+        () -> manager.createOrUpdateAndStartSupervisor(new TestSupervisorSpec("id", null), false)
+    );
   }
 
   @Test
@@ -218,10 +215,11 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(ImmutableMap.of());
     replayAll();
 
-    exception.expect(NullPointerException.class);
-
     manager.start();
-    manager.createOrUpdateAndStartSupervisor(null, false);
+    Assertions.assertThrows(
+        NullPointerException.class,
+        () -> manager.createOrUpdateAndStartSupervisor(null, false)
+    );
     verifyAll();
   }
 
@@ -231,10 +229,11 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(ImmutableMap.of());
     replayAll();
 
-    exception.expect(NullPointerException.class);
-
     manager.start();
-    manager.createOrUpdateAndStartSupervisor(new TestSupervisorSpec(null, null), false);
+    Assertions.assertThrows(
+        NullPointerException.class,
+        () -> manager.createOrUpdateAndStartSupervisor(new TestSupervisorSpec(null, null), false)
+    );
     verifyAll();
   }
 
@@ -249,8 +248,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
     manager.start();
     final SupervisorSpecUpdateResult result = manager.createOrUpdateAndStartSupervisor(spec, true);
-    Assert.assertFalse(result.isModified());
-    Assert.assertFalse(result.isRestarted());
+    Assertions.assertFalse(result.isModified());
+    Assertions.assertFalse(result.isRestarted());
     verifyAll();
   }
 
@@ -274,8 +273,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     metadataSupervisorManager.insert(EasyMock.eq("id2"), EasyMock.anyObject());
     replayAll();
     final SupervisorSpecUpdateResult result = manager.createOrUpdateAndStartSupervisor(spec2, true);
-    Assert.assertTrue(result.isModified());
-    Assert.assertTrue(result.isRestarted());
+    Assertions.assertTrue(result.isModified());
+    Assertions.assertTrue(result.isRestarted());
     verifyAll();
   }
 
@@ -296,10 +295,10 @@ public class SupervisorManagerTest extends EasyMockSupport
     // version differs (byte change) but requireRestart() is false.
     final SupervisorSpec updated = new VersionedTestSupervisorSpec("id1", supervisor1, 2);
     final SupervisorSpecUpdateResult updateResult = manager.createOrUpdateAndStartSupervisor(updated, true);
-    Assert.assertTrue(updateResult.isModified());
-    Assert.assertFalse(updateResult.isRestarted());
-    Assert.assertSame(updated, capturedInsert.getValue());
-    Assert.assertSame(updated, manager.getSupervisorSpec("id1").get());
+    Assertions.assertTrue(updateResult.isModified());
+    Assertions.assertFalse(updateResult.isRestarted());
+    Assertions.assertSame(updated, capturedInsert.getValue());
+    Assertions.assertSame(updated, manager.getSupervisorSpec("id1").get());
     verifyAll();
   }
 
@@ -316,8 +315,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     manager.start();
     final SupervisorSpecUpdateResult updateResult =
         manager.createOrUpdateAndStartSupervisor(new TestSupervisorSpec("id1", supervisor1), true);
-    Assert.assertFalse(updateResult.isModified());
-    Assert.assertFalse(updateResult.isRestarted());
+    Assertions.assertFalse(updateResult.isModified());
+    Assertions.assertFalse(updateResult.isRestarted());
     verifyAll();
   }
 
@@ -345,9 +344,9 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     final SupervisorSpec updated = new VersionedTestSupervisorSpec("id1", supervisor1, 2);
     final SupervisorSpecUpdateResult updateResult = manager.createOrUpdateAndStartSupervisor(updated, true);
-    Assert.assertTrue(updateResult.isModified());
-    Assert.assertTrue(updateResult.isRestarted());
-    Assert.assertSame(updated, manager.getSupervisorSpec("id1").get());
+    Assertions.assertTrue(updateResult.isModified());
+    Assertions.assertTrue(updateResult.isRestarted());
+    Assertions.assertSame(updated, manager.getSupervisorSpec("id1").get());
     verifyAll();
   }
 
@@ -366,10 +365,10 @@ public class SupervisorManagerTest extends EasyMockSupport
     final MergingVersionedTestSupervisorSpec updated =
         new MergingVersionedTestSupervisorSpec("id1", supervisor1, null);
     final SupervisorSpecUpdateResult updateResult = manager.createOrUpdateAndStartSupervisor(updated, true);
-    Assert.assertFalse(updateResult.isModified());
-    Assert.assertFalse(updateResult.isRestarted());
-    Assert.assertEquals(Integer.valueOf(1), updated.getVersion());
-    Assert.assertSame(existing, manager.getSupervisorSpec("id1").get());
+    Assertions.assertFalse(updateResult.isModified());
+    Assertions.assertFalse(updateResult.isRestarted());
+    Assertions.assertEquals(Integer.valueOf(1), updated.getVersion());
+    Assertions.assertSame(existing, manager.getSupervisorSpec("id1").get());
     verifyAll();
   }
 
@@ -392,8 +391,8 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     final SupervisorSpecUpdateResult updateResult =
         manager.createOrUpdateAndStartSupervisor(new TestSupervisorSpec("id1", supervisor1), false);
-    Assert.assertFalse(updateResult.isModified());
-    Assert.assertTrue(updateResult.isRestarted());
+    Assertions.assertFalse(updateResult.isModified());
+    Assertions.assertTrue(updateResult.isRestarted());
     verifyAll();
   }
 
@@ -415,18 +414,19 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(existingSpecs);
     supervisor1.start();
     EasyMock.expect(supervisor1.createAutoscaler(EasyMock.anyObject())).andReturn(null).anyTimes();
-    exception.expect(DruidException.class);
     replayAll();
     manager.start();
-    manager.createOrUpdateAndStartSupervisor(spec2, true);
+    Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.createOrUpdateAndStartSupervisor(spec2, true)
+    );
     verifyAll();
   }
 
   @Test
   public void testStopAndRemoveSupervisorNotStarted()
   {
-    exception.expect(IllegalStateException.class);
-    manager.stopAndRemoveSupervisor("id");
+    Assertions.assertThrows(IllegalStateException.class, () -> manager.stopAndRemoveSupervisor("id"));
   }
 
   @Test
@@ -435,10 +435,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(ImmutableMap.of());
     replayAll();
 
-    exception.expect(NullPointerException.class);
-
     manager.start();
-    manager.stopAndRemoveSupervisor(null);
+    Assertions.assertThrows(NullPointerException.class, () -> manager.stopAndRemoveSupervisor(null));
     verifyAll();
   }
 
@@ -453,7 +451,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     Map<String, List<VersionedSupervisorSpec>> history = manager.getSupervisorHistory();
     verifyAll();
 
-    Assert.assertEquals(supervisorHistory, history);
+    Assertions.assertEquals(supervisorHistory, history);
   }
 
   @Test
@@ -468,7 +466,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     List<VersionedSupervisorSpec> history = manager.getSupervisorHistoryForId(id, null);
     verifyAll();
 
-    Assert.assertEquals(supervisorHistory, history);
+    Assertions.assertEquals(supervisorHistory, history);
   }
 
   @Test
@@ -484,7 +482,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     List<VersionedSupervisorSpec> history = manager.getSupervisorHistoryForId(id, limit);
     verifyAll();
 
-    Assert.assertEquals(supervisorHistory, history);
+    Assertions.assertEquals(supervisorHistory, history);
   }
 
   @Test
@@ -504,8 +502,8 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     manager.start();
 
-    Assert.assertEquals(Optional.absent(), manager.getSupervisorStatus("non-existent-id"));
-    Assert.assertEquals(report, manager.getSupervisorStatus("id1").get());
+    Assertions.assertEquals(Optional.absent(), manager.getSupervisorStatus("non-existent-id"));
+    Assertions.assertEquals(report, manager.getSupervisorStatus("id1").get());
 
     verifyAll();
   }
@@ -519,7 +517,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     manager.start();
 
     Collection<SupervisorStatsProvider.SupervisorStats> stats = manager.getSupervisorStats();
-    Assert.assertTrue(stats.isEmpty());
+    Assertions.assertTrue(stats.isEmpty());
 
     verifyAll();
   }
@@ -540,15 +538,15 @@ public class SupervisorManagerTest extends EasyMockSupport
     manager.start();
 
     Collection<SupervisorStatsProvider.SupervisorStats> stats = manager.getSupervisorStats();
-    Assert.assertEquals(1, stats.size());
+    Assertions.assertEquals(1, stats.size());
 
     SupervisorStatsProvider.SupervisorStats stat = stats.iterator().next();
-    Assert.assertEquals("id1", stat.getSupervisorId());
-    Assert.assertEquals("TestSupervisorSpec", stat.getType());
-    Assert.assertEquals("RUNNING", stat.getState());
-    Assert.assertEquals("id1", stat.getDataSource());
-    Assert.assertEquals("", stat.getStream());
-    Assert.assertEquals("RUNNING", stat.getDetailedState());
+    Assertions.assertEquals("id1", stat.getSupervisorId());
+    Assertions.assertEquals("TestSupervisorSpec", stat.getType());
+    Assertions.assertEquals("RUNNING", stat.getState());
+    Assertions.assertEquals("id1", stat.getDataSource());
+    Assertions.assertEquals("", stat.getStream());
+    Assertions.assertEquals("RUNNING", stat.getDetailedState());
 
     verifyAll();
   }
@@ -569,13 +567,13 @@ public class SupervisorManagerTest extends EasyMockSupport
     manager.start();
 
     Collection<SupervisorStatsProvider.SupervisorStats> stats = manager.getSupervisorStats();
-    Assert.assertEquals(1, stats.size());
+    Assertions.assertEquals(1, stats.size());
 
     SupervisorStatsProvider.SupervisorStats stat = stats.iterator().next();
-    Assert.assertEquals("id1", stat.getSupervisorId());
-    Assert.assertEquals("TestSupervisorSpec", stat.getType());
-    Assert.assertEquals("UNKNOWN", stat.getState());
-    Assert.assertEquals("UNKNOWN", stat.getDetailedState());
+    Assertions.assertEquals("id1", stat.getSupervisorId());
+    Assertions.assertEquals("TestSupervisorSpec", stat.getType());
+    Assertions.assertEquals("UNKNOWN", stat.getState());
+    Assertions.assertEquals("UNKNOWN", stat.getDetailedState());
 
     verifyAll();
   }
@@ -592,7 +590,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     supervisorsMap.put("id1", new Pair<>(null, new TestSupervisorSpec("id1", supervisor1)));
 
     final Collection<SupervisorStatsProvider.SupervisorStats> stats = manager.getSupervisorStats();
-    Assert.assertTrue(stats.isEmpty());
+    Assertions.assertTrue(stats.isEmpty());
 
     verifyAll();
   }
@@ -611,11 +609,11 @@ public class SupervisorManagerTest extends EasyMockSupport
     supervisorsMap.put("id2", new Pair<>(supervisor2, new TestSupervisorSpec("id2", supervisor2)));
 
     final Collection<SupervisorStatsProvider.SupervisorStats> stats = manager.getSupervisorStats();
-    Assert.assertEquals(1, stats.size());
+    Assertions.assertEquals(1, stats.size());
 
     final SupervisorStatsProvider.SupervisorStats stat = stats.iterator().next();
-    Assert.assertEquals("id2", stat.getSupervisorId());
-    Assert.assertEquals("RUNNING", stat.getState());
+    Assertions.assertEquals("id2", stat.getSupervisorId());
+    Assertions.assertEquals("RUNNING", stat.getState());
 
     verifyAll();
   }
@@ -644,8 +642,8 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     manager.start();
 
-    Assert.assertTrue(manager.handoffTaskGroupsEarly("id1", ImmutableList.of(1)));
-    Assert.assertFalse(manager.handoffTaskGroupsEarly("id2", ImmutableList.of(1)));
+    Assertions.assertTrue(manager.handoffTaskGroupsEarly("id1", ImmutableList.of(1)));
+    Assertions.assertFalse(manager.handoffTaskGroupsEarly("id2", ImmutableList.of(1)));
 
     verifyAll();
   }
@@ -665,15 +663,16 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     manager.start();
 
-    MatcherAssert.assertThat(
-        Assert.assertThrows(DruidException.class, () -> manager.handoffTaskGroupsEarly("id3", ImmutableList.of(1))),
-        new DruidExceptionMatcher(
-            DruidException.Persona.USER,
-            DruidException.Category.UNSUPPORTED,
-            "general"
-        ).expectMessageIs(
-                "Operation[handoff] is not supported by supervisor[id3] of type[TestSupervisorSpec]."
-        )
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.handoffTaskGroupsEarly("id3", ImmutableList.of(1))
+    );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.UNSUPPORTED, exception.getCategory());
+    Assertions.assertEquals("general", exception.getErrorCode());
+    Assertions.assertEquals(
+        "Operation[handoff] is not supported by supervisor[id3] of type[TestSupervisorSpec].",
+        exception.getMessage()
     );
     verifyAll();
   }
@@ -684,10 +683,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(ImmutableMap.of());
     replayAll();
 
-    exception.expect(IllegalStateException.class);
-
-    manager.start();
     manager.start();
+    Assertions.assertThrows(IllegalStateException.class, () -> manager.start());
   }
 
   @Test
@@ -715,8 +712,6 @@ public class SupervisorManagerTest extends EasyMockSupport
   @Test
   public void testNoPersistOnFailedStart()
   {
-    exception.expect(RuntimeException.class);
-
     Capture<TestSupervisorSpec> capturedInsert = Capture.newInstance();
 
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(Collections.emptyMap());
@@ -733,14 +728,14 @@ public class SupervisorManagerTest extends EasyMockSupport
     final SupervisorSpec testSpecNew = new TestSupervisorSpec("id1", supervisor2);
 
     manager.start();
-    try {
-      manager.createOrUpdateAndStartSupervisor(testSpecOld, false);
-      manager.createOrUpdateAndStartSupervisor(testSpecNew, false);
-    }
-    catch (Exception e) {
-      Assert.assertEquals(testSpecOld, capturedInsert.getValue());
-      throw e;
-    }
+    Assertions.assertThrows(
+        RuntimeException.class,
+        () -> {
+          manager.createOrUpdateAndStartSupervisor(testSpecOld, false);
+          manager.createOrUpdateAndStartSupervisor(testSpecNew, false);
+        }
+    );
+    Assertions.assertEquals(testSpecOld, capturedInsert.getValue());
   }
 
   @Test
@@ -776,8 +771,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.start();
-    Assert.assertTrue("resetValidSupervisor", manager.resetSupervisor("id1", null));
-    Assert.assertFalse("resetInvalidSupervisor", manager.resetSupervisor("nobody_home", null));
+    Assertions.assertTrue(manager.resetSupervisor("id1", null), "resetValidSupervisor");
+    Assertions.assertFalse(manager.resetSupervisor("nobody_home", null), "resetInvalidSupervisor");
 
     verifyAll();
   }
@@ -796,15 +791,16 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     manager.start();
 
-    MatcherAssert.assertThat(
-        Assert.assertThrows(DruidException.class, () -> manager.resetSupervisor("id3", null)),
-        new DruidExceptionMatcher(
-            DruidException.Persona.USER,
-            DruidException.Category.UNSUPPORTED,
-            "general"
-        ).expectMessageIs(
-            "Operation[reset] is not supported by supervisor[id3] of type[TestSupervisorSpec]."
-        )
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.resetSupervisor("id3", null)
+    );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.UNSUPPORTED, exception.getCategory());
+    Assertions.assertEquals("general", exception.getErrorCode());
+    Assertions.assertEquals(
+        "Operation[reset] is not supported by supervisor[id3] of type[TestSupervisorSpec].",
+        exception.getMessage()
     );
 
     verifyAll();
@@ -832,8 +828,8 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.start();
-    Assert.assertTrue("resetValidSupervisor", manager.resetSupervisor("id1", datasourceMetadata));
-    Assert.assertFalse("resetInvalidSupervisor", manager.resetSupervisor("nobody_home", datasourceMetadata));
+    Assertions.assertTrue(manager.resetSupervisor("id1", datasourceMetadata), "resetValidSupervisor");
+    Assertions.assertFalse(manager.resetSupervisor("nobody_home", datasourceMetadata), "resetInvalidSupervisor");
 
     verifyAll();
   }
@@ -848,7 +844,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     );
 
     // mock adding a supervisor to manager with existing supervisor then suspending it
-    Assert.assertTrue(manager.getSupervisorIds().isEmpty());
+    Assertions.assertTrue(manager.getSupervisorIds().isEmpty());
 
     EasyMock.expect(metadataSupervisorManager.getLatest()).andReturn(existingSpecs);
     metadataSupervisorManager.insert("id1", spec);
@@ -859,11 +855,11 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.start();
-    Assert.assertEquals(1, manager.getSupervisorIds().size());
+    Assertions.assertEquals(1, manager.getSupervisorIds().size());
 
     manager.createOrUpdateAndStartSupervisor(spec, false);
-    Assert.assertEquals(2, manager.getSupervisorIds().size());
-    Assert.assertEquals(spec, manager.getSupervisorSpec("id1").get());
+    Assertions.assertEquals(2, manager.getSupervisorIds().size());
+    Assertions.assertEquals(spec, manager.getSupervisorSpec("id1").get());
     verifyAll();
 
     // mock suspend, which stops supervisor1 and sets suspended state in metadata, flipping to supervisor2
@@ -876,9 +872,9 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.suspendOrResumeSupervisor("id1", true);
-    Assert.assertEquals(2, manager.getSupervisorIds().size());
-    Assert.assertEquals(capturedInsert.getValue(), manager.getSupervisorSpec("id1").get());
-    Assert.assertTrue(capturedInsert.getValue().suspended);
+    Assertions.assertEquals(2, manager.getSupervisorIds().size());
+    Assertions.assertEquals(capturedInsert.getValue(), manager.getSupervisorSpec("id1").get());
+    Assertions.assertTrue(capturedInsert.getValue().suspended);
     verifyAll();
 
     // mock resume, which stops supervisor2 and sets suspended to false in metadata, flipping to supervisor1
@@ -891,9 +887,9 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     manager.suspendOrResumeSupervisor("id1", false);
-    Assert.assertEquals(2, manager.getSupervisorIds().size());
-    Assert.assertEquals(capturedInsert.getValue(), manager.getSupervisorSpec("id1").get());
-    Assert.assertFalse(capturedInsert.getValue().suspended);
+    Assertions.assertEquals(2, manager.getSupervisorIds().size());
+    Assertions.assertEquals(capturedInsert.getValue(), manager.getSupervisorSpec("id1").get());
+    Assertions.assertFalse(capturedInsert.getValue().suspended);
     verifyAll();
 
     // mock stop of suspended then resumed supervisor
@@ -903,9 +899,9 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
 
     boolean retVal = manager.stopAndRemoveSupervisor("id1");
-    Assert.assertTrue(retVal);
-    Assert.assertEquals(1, manager.getSupervisorIds().size());
-    Assert.assertEquals(Optional.absent(), manager.getSupervisorSpec("id1"));
+    Assertions.assertTrue(retVal);
+    Assertions.assertEquals(1, manager.getSupervisorIds().size());
+    Assertions.assertEquals(Optional.absent(), manager.getSupervisorSpec("id1"));
     verifyAll();
 
     // mock manager shutdown to ensure supervisor 3 stops
@@ -918,7 +914,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     manager.stop();
     verifyAll();
 
-    Assert.assertTrue(manager.getSupervisorIds().isEmpty());
+    Assertions.assertTrue(manager.getSupervisorIds().isEmpty());
   }
 
   @Test
@@ -1002,25 +998,25 @@ public class SupervisorManagerTest extends EasyMockSupport
     replayAll();
     manager.start();
 
-    Assert.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("nonExistent").isEmpty());
+    Assertions.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("nonExistent").isEmpty());
 
     manager.createOrUpdateAndStartSupervisor(noopSupervisorSpec, false);
-    Assert.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("noopDS").isEmpty());
+    Assertions.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("noopDS").isEmpty());
 
     manager.createOrUpdateAndStartSupervisor(suspendedSpec, false);
-    Assert.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeDS").isEmpty());
+    Assertions.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeDS").isEmpty());
 
     manager.createOrUpdateAndStartSupervisor(activeSpec, false);
-    Assert.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeDS").isEmpty());
+    Assertions.assertTrue(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeDS").isEmpty());
 
     manager.createOrUpdateAndStartSupervisor(activeAppendSpec, false);
-    Assert.assertFalse(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeAppendDS").isEmpty());
+    Assertions.assertFalse(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeAppendDS").isEmpty());
 
     manager.createOrUpdateAndStartSupervisor(activeSpecWithConcurrentLocks, false);
-    Assert.assertFalse(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeConcurrentLocksDS").isEmpty());
+    Assertions.assertFalse(manager.getActiveSupervisorIdsForDatasourceWithAppendLock("activeConcurrentLocksDS").isEmpty());
 
     manager.createOrUpdateAndStartSupervisor(specWithUseConcurrentLocksFalse, false);
-    Assert.assertTrue(
+    Assertions.assertTrue(
         manager.getActiveSupervisorIdsForDatasourceWithAppendLock("dsWithUseConcurrentLocksFalse").isEmpty()
     );
 
@@ -1065,10 +1061,10 @@ public class SupervisorManagerTest extends EasyMockSupport
     manager.start();
 
     manager.createOrUpdateAndStartSupervisor(noopSpec, false);
-    Assert.assertFalse(manager.registerUpgradedPendingSegmentOnSupervisor("noop", pendingSegment).isPresent());
+    Assertions.assertFalse(manager.registerUpgradedPendingSegmentOnSupervisor("noop", pendingSegment).isPresent());
 
     manager.createOrUpdateAndStartSupervisor(streamingSpec, false);
-    Assert.assertEquals(OptionalInt.of(1), manager.registerUpgradedPendingSegmentOnSupervisor("sss", pendingSegment));
+    Assertions.assertEquals(OptionalInt.of(1), manager.registerUpgradedPendingSegmentOnSupervisor("sss", pendingSegment));
 
     verifyAll();
   }
@@ -1076,25 +1072,27 @@ public class SupervisorManagerTest extends EasyMockSupport
   @Test
   public void test_isAnotherTaskGroupPublishingToPartitions_throwsException_ifSupervisorIdIsNull()
   {
-    MatcherAssert.assertThat(
-        Assert.assertThrows(
-            DruidException.class,
-            () -> manager.isAnotherTaskGroupPublishingToPartitions(null, "task1", null)
-        ),
-        DruidExceptionMatcher.invalidInput().expectMessageIs("'supervisorId' cannot be null")
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.isAnotherTaskGroupPublishingToPartitions(null, "task1", null)
     );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.INVALID_INPUT, exception.getCategory());
+    Assertions.assertEquals("invalidInput", exception.getErrorCode());
+    Assertions.assertEquals("'supervisorId' cannot be null", exception.getMessage());
   }
 
   @Test
   public void test_isAnotherTaskGroupPublishingToPartitions_throwsException_ifSupervisorNotFound()
   {
-    MatcherAssert.assertThat(
-        Assert.assertThrows(
-            DruidException.class,
-            () -> manager.isAnotherTaskGroupPublishingToPartitions("supervisor1", "task1", null)
-        ),
-        DruidExceptionMatcher.notFound().expectMessageIs("Could not find supervisor[supervisor1]")
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.isAnotherTaskGroupPublishingToPartitions("supervisor1", "task1", null)
     );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.NOT_FOUND, exception.getCategory());
+    Assertions.assertEquals("notFound", exception.getErrorCode());
+    Assertions.assertEquals("Could not find supervisor[supervisor1]", exception.getMessage());
   }
 
   @Test
@@ -1111,7 +1109,7 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     manager.start();
 
-    Assert.assertFalse(
+    Assertions.assertFalse(
         manager.isAnotherTaskGroupPublishingToPartitions(supervisorId, "task1", null)
     );
   }
@@ -1133,14 +1131,16 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     manager.start();
 
-    MatcherAssert.assertThat(
-        Assert.assertThrows(
-            DruidException.class,
-            () -> manager.isAnotherTaskGroupPublishingToPartitions(supervisorId, "task1", null)
-        ),
-        DruidExceptionMatcher.invalidInput().expectMessageIs(
-            "Start metadata[null] of type[null] is not valid streaming metadata"
-        )
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.isAnotherTaskGroupPublishingToPartitions(supervisorId, "task1", null)
+    );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.INVALID_INPUT, exception.getCategory());
+    Assertions.assertEquals("invalidInput", exception.getErrorCode());
+    Assertions.assertEquals(
+        "Start metadata[null] of type[null] is not valid streaming metadata",
+        exception.getMessage()
     );
   }
 
@@ -1161,16 +1161,18 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     manager.start();
 
-    MatcherAssert.assertThat(
-        Assert.assertThrows(
-            DruidException.class,
-            () -> manager.isAnotherTaskGroupPublishingToPartitions(supervisorId, "task1", new ObjectMetadata("abc"))
-        ),
-        DruidExceptionMatcher.invalidInput().expectMessageIs(
-            "Start metadata[ObjectMetadata{theObject=abc}] of"
-            + " type[class org.apache.druid.indexing.overlord.ObjectMetadata]"
-            + " is not valid streaming metadata"
-        )
+    final DruidException exception = Assertions.assertThrows(
+        DruidException.class,
+        () -> manager.isAnotherTaskGroupPublishingToPartitions(supervisorId, "task1", new ObjectMetadata("abc"))
+    );
+    Assertions.assertEquals(DruidException.Persona.USER, exception.getTargetPersona());
+    Assertions.assertEquals(DruidException.Category.INVALID_INPUT, exception.getCategory());
+    Assertions.assertEquals("invalidInput", exception.getErrorCode());
+    Assertions.assertEquals(
+        "Start metadata[ObjectMetadata{theObject=abc}] of"
+        + " type[class org.apache.druid.indexing.overlord.ObjectMetadata]"
+        + " is not valid streaming metadata",
+        exception.getMessage()
     );
   }
 
@@ -1213,10 +1215,10 @@ public class SupervisorManagerTest extends EasyMockSupport
         "topic",
         Map.of("0", "10")
     );
-    Assert.assertTrue(
+    Assertions.assertTrue(
         manager.isAnotherTaskGroupPublishingToPartitions(supervisorId, conflictingTaskId, startMetadata)
     );
-    Assert.assertFalse(
+    Assertions.assertFalse(
         manager.isAnotherTaskGroupPublishingToPartitions(supervisorId, readyTaskId, startMetadata)
     );
   }
@@ -1267,7 +1269,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(streamSpec.getType()).andReturn("stream").anyTimes();
     EasyMock.replay(streamSpec);
     supervisorsMap.put("id1", Pair.of(nonStreamSupervisor, streamSpec));
-    Assert.assertThrows(
+    Assertions.assertThrows(
         DruidException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1278,7 +1280,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(streamSupervisor.getIoConfig()).andReturn(ioConfig).anyTimes();
     EasyMock.expect(ioConfig.isUseEarliestSequenceNumber()).andReturn(true).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1289,7 +1291,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(ioConfig.isUseEarliestSequenceNumber()).andReturn(false).once();
     EasyMock.expect(streamSpec.getContext()).andReturn(null).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1300,7 +1302,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(ioConfig.isUseEarliestSequenceNumber()).andReturn(false).once();
     EasyMock.expect(streamSpec.getContext()).andReturn(ImmutableMap.of("useConcurrentLocks", false)).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1312,7 +1314,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(streamSpec.getContext()).andReturn(ImmutableMap.of("useConcurrentLocks", "true")).once();
     EasyMock.expect(streamSupervisor.getState()).andReturn(SupervisorStateManager.BasicState.SUSPENDED).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1324,7 +1326,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(streamSpec.getContext()).andReturn(ImmutableMap.of("taskLockType", "APPEND")).once();
     EasyMock.expect(streamSupervisor.getState()).andReturn(SupervisorStateManager.BasicState.SUSPENDED).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1336,7 +1338,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(streamSpec.getContext()).andReturn(ImmutableMap.of("useConcurrentLocks", true)).once();
     EasyMock.expect(streamSupervisor.getState()).andReturn(SupervisorStateManager.BasicState.SUSPENDED).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1351,7 +1353,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expectLastCall().once();
     EasyMock.expect(streamSupervisor.getLatestSequencesFromStream()).andReturn(ImmutableMap.of()).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalStateException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1367,7 +1369,7 @@ public class SupervisorManagerTest extends EasyMockSupport
     EasyMock.expect(streamSupervisor.getLatestSequencesFromStream()).andReturn(ImmutableMap.of("0", 100L)).once();
     EasyMock.expect(streamSupervisor.getOffsetsFromMetadataStorage()).andReturn(ImmutableMap.of()).once();
     EasyMock.replay(streamSupervisor, streamSpec, ioConfig);
-    Assert.assertThrows(
+    Assertions.assertThrows(
         IllegalStateException.class,
         () -> manager.resetToLatestAndBackfill("id1", null)
     );
@@ -1389,19 +1391,19 @@ public class SupervisorManagerTest extends EasyMockSupport
 
     // Without overriding taskCount
     final SupervisorSpec backfillSpec = sourceSpec.createBackfillSpec("backfill-id", boundedStreamConfig, null);
-    Assert.assertEquals("backfill-id", backfillSpec.getId());
+    Assertions.assertEquals("backfill-id", backfillSpec.getId());
     final TestBackfillSupervisorSpec backfillCast = (TestBackfillSupervisorSpec) backfillSpec;
     final BoundedStreamConfig actualConfig = backfillCast.getIoConfig().getBoundedStreamConfig();
-    Assert.assertNotNull(actualConfig);
-    Assert.assertEquals(ImmutableMap.of("0", 100L), actualConfig.getStartSequenceNumbers());
-    Assert.assertEquals(ImmutableMap.of("0", 200L), actualConfig.getEndSequenceNumbers());
-    Assert.assertEquals(1, backfillCast.getIoConfig().getTaskCount());
+    Assertions.assertNotNull(actualConfig);
+    Assertions.assertEquals(ImmutableMap.of("0", 100L), actualConfig.getStartSequenceNumbers());
+    Assertions.assertEquals(ImmutableMap.of("0", 200L), actualConfig.getEndSequenceNumbers());
+    Assertions.assertEquals(1, backfillCast.getIoConfig().getTaskCount());
 
     // With overriding taskCount
     final SupervisorSpec backfillSpecWithCount = sourceSpec.createBackfillSpec("backfill-id-2", boundedStreamConfig, 5);
-    Assert.assertEquals("backfill-id-2", backfillSpecWithCount.getId());
+    Assertions.assertEquals("backfill-id-2", backfillSpecWithCount.getId());
     final TestBackfillSupervisorSpec backfillWithCount = (TestBackfillSupervisorSpec) backfillSpecWithCount;
-    Assert.assertEquals(5, backfillWithCount.getIoConfig().getTaskCount());
+    Assertions.assertEquals(5, backfillWithCount.getIoConfig().getTaskCount());
   }
 
   private static class TestSupervisorSpec implements SupervisorSpec
diff --git a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/autoscaler/LagBasedAutoScalerConfigTest.java b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/autoscaler/LagBasedAutoScalerConfigTest.java
index db9bdb3d0c8..f3b336dae9b 100644
--- a/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/autoscaler/LagBasedAutoScalerConfigTest.java
+++ b/indexing-service/src/test/java/org/apache/druid/indexing/overlord/supervisor/autoscaler/LagBasedAutoScalerConfigTest.java
@@ -23,8 +23,8 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.druid.indexing.seekablestream.supervisor.autoscaler.LagBasedAutoScalerConfig;
 import org.apache.druid.jackson.DefaultObjectMapper;
 import org.joda.time.Duration;
-import org.junit.Assert;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 public class LagBasedAutoScalerConfigTest
 {
@@ -55,26 +55,26 @@ public class LagBasedAutoScalerConfigTest
         null
     );
 
-    Assert.assertFalse(config.getEnableTaskAutoScaler());
-    Assert.assertEquals(30000, config.getLagCollectionIntervalMillis());
-    Assert.assertEquals(600000, config.getLagCollectionRangeMillis());
-    Assert.assertEquals(300000, config.getScaleActionStartDelayMillis());
-    Assert.assertEquals(60000, config.getScaleActionPeriodMillis());
-    Assert.assertEquals(6000000, config.getScaleOutThreshold());
-    Assert.assertEquals(1000000, config.getScaleInThreshold());
-    Assert.assertEquals(0.3, config.getTriggerScaleOutFractionThreshold(), 0.00001);
-    Assert.assertEquals(0.9, config.getTriggerScaleInFractionThreshold(), 0.00001);
-    Assert.assertEquals(1, config.getScaleInStep());
-    Assert.assertEquals(2, config.getScaleOutStep());
-    Assert.assertEquals(600000, config.getMinTriggerScaleActionFrequencyMillis());
+    Assertions.assertFalse(config.getEnableTaskAutoScaler());
+    Assertions.assertEquals(30000, config.getLagCollectionIntervalMillis());
+    Assertions.assertEquals(600000, config.getLagCollectionRangeMillis());
+    Assertions.assertEquals(300000, config.getScaleActionStartDelayMillis());
+    Assertions.assertEquals(60000, config.getScaleActionPeriodMillis());
+    Assertions.assertEquals(6000000, config.getScaleOutThreshold());
+    Assertions.assertEquals(1000000, config.getScaleInThreshold());
+    Assertions.assertEquals(0.3, config.getTriggerScaleOutFractionThreshold(), 0.00001);
+    Assertions.assertEquals(0.9, config.getTriggerScaleInFractionThreshold(), 0.00001);
+    Assertions.assertEquals(1, config.getScaleInStep());
+    Assertions.assertEquals(2, config.getScaleOutStep());
+    Assertions.assertEquals(600000, config.getMinTriggerScaleActionFrequencyMillis());
     // When minScaleUpDelay/minScaleDownDelay are not set, they fall back to minTriggerScaleActionFrequencyMillis
-    Assert.assertEquals(Duration.millis(600000), config.getMinScaleUpDelay());
-    Assert.assertEquals(Duration.millis(600000), config.getMinScaleDownDelay());
-    Assert.assertNull(config.getLagAggregate());
-    Assert.assertNull(config.getStopTaskCountRatio());
-    Assert.assertEquals(0, config.getTaskCountMax());
-    Assert.assertEquals(0, config.getTaskCountMin());
-    Assert.assertNull(config.getTaskCountStart());
+    Assertions.assertEquals(Duration.millis(600000), config.getMinScaleUpDelay());
+    Assertions.assertEquals(Duration.millis(600000), config.getMinScaleDownDelay());
+    Assertions.assertNull(config.getLagAggregate());
+    Assertions.assertNull(config.getStopTaskCountRatio());
+    Assertions.assertEquals(0, config.getTaskCountMax());
+    Assertions.assertEquals(0, config.getTaskCountMin());
+    Assertions.assertNull(config.getTaskCountStart());
   }
 
   @Test
@@ -107,14 +107,14 @@ public class LagBasedAutoScalerConfigTest
         ), LagBasedAutoScalerConfig.class
     );
 
-    Assert.assertEquals(config1, config2);
+    Assertions.assertEquals(config1, config2);
   }
 
   @Test
   public void testEnabledTaskCountChecks()
   {
     // Should throw if taskCountMax or taskCountMin is missing
-    RuntimeException ex1 = Assert.assertThrows(
+    RuntimeException ex1 = Assertions.assertThrows(
         RuntimeException.class,
         () ->
             new LagBasedAutoScalerConfig(
@@ -139,10 +139,10 @@ public class LagBasedAutoScalerConfigTest
                 null
             )
     );
-    Assert.assertTrue(ex1.getMessage().contains("taskCountMax or taskCountMin can't be null"));
+    Assertions.assertTrue(ex1.getMessage().contains("taskCountMax or taskCountMin can't be null"));
 
     // Should throw if taskCountMax < taskCountMin
-    RuntimeException ex2 = Assert.assertThrows(
+    RuntimeException ex2 = Assertions.assertThrows(
         RuntimeException.class,
         () ->
             new LagBasedAutoScalerConfig(
@@ -167,10 +167,10 @@ public class LagBasedAutoScalerConfigTest
                 null
             )
     );
-    Assert.assertTrue(ex2.getMessage().contains("taskCountMax can't lower than taskCountMin"));
+    Assertions.assertTrue(ex2.getMessage().contains("taskCountMax can't lower than taskCountMin"));
 
     // Should throw if taskCountStart out of range
-    RuntimeException ex3 = Assert.assertThrows(
+    RuntimeException ex3 = Assertions.assertThrows(
         RuntimeException.class,
         () ->
             new LagBasedAutoScalerConfig(
@@ -195,14 +195,14 @@ public class LagBasedAutoScalerConfigTest
                 null
             )
     );
-    Assert.assertTrue(ex3.getMessage().contains("taskCountMin <= taskCountStart <= taskCountMax"));
+    Assertions.assertTrue(ex3.getMessage().contains("taskCountMin <= taskCountStart <= taskCountMax"));
   }
 
   @Test
   public void testStopTaskCountRatioBounds()
   {
     // Fail if stopTaskCountRatio = 0
-    IllegalArgumentException ex1 = Assert.assertThrows(
+    IllegalArgumentException ex1 = Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> new LagBasedAutoScalerConfig(
             null,
@@ -226,10 +226,10 @@ public class LagBasedAutoScalerConfigTest
             0.0
         )
     );
-    Assert.assertTrue(ex1.getMessage().contains("0.0 < stopTaskCountRatio <= 1.0"));
+    Assertions.assertTrue(ex1.getMessage().contains("0.0 < stopTaskCountRatio <= 1.0"));
 
     // Fail if stopTaskCountRatio < 0
-    IllegalArgumentException ex2 = Assert.assertThrows(
+    IllegalArgumentException ex2 = Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> new LagBasedAutoScalerConfig(
             null,
@@ -252,10 +252,10 @@ public class LagBasedAutoScalerConfigTest
             -0.1
         )
     );
-    Assert.assertTrue(ex2.getMessage().contains("0.0 < stopTaskCountRatio <= 1.0"));
+    Assertions.assertTrue(ex2.getMessage().contains("0.0 < stopTaskCountRatio <= 1.0"));
 
     // Fail if stopTaskCountRatio > 1.0
-    IllegalArgumentException ex3 = Assert.assertThrows(
+    IllegalArgumentException ex3 = Assertions.assertThrows(
         IllegalArgumentException.class,
         () -> new LagBasedAutoScalerConfig(
             null,
@@ -279,7 +279,7 @@ public class LagBasedAutoScalerConfigTest
             1.1
         )
     );
-    Assert.assertTrue(ex3.getMessage().contains("0.0 < stopTaskCountRatio <= 1.0"));
+    Assertions.assertTrue(ex3.getMessage().contains("0.0 < stopTaskCountRatio <= 1.0"));
 
     // Should succeed for a valid value
     LagBasedAutoScalerConfig config = new LagBasedAutoScalerConfig(
@@ -303,7 +303,7 @@ public class LagBasedAutoScalerConfigTest
         null,
         0.5
     );
-    Assert.assertEquals(Double.valueOf(0.5), config.getStopTaskCountRatio());
+    Assertions.assertEquals(Double.valueOf(0.5), config.getStopTaskCountRatio());
   }
 
   @Test
@@ -331,9 +331,9 @@ public class LagBasedAutoScalerConfigTest
         null,
         null
     );
-    Assert.assertEquals(60000L, baseOnly.getMinTriggerScaleActionFrequencyMillis());
-    Assert.assertEquals(Duration.millis(60000), baseOnly.getMinScaleUpDelay());
-    Assert.assertEquals(Duration.millis(60000), baseOnly.getMinScaleDownDelay());
+    Assertions.assertEquals(60000L, baseOnly.getMinTriggerScaleActionFrequencyMillis());
+    Assertions.assertEquals(Duration.millis(60000), baseOnly.getMinScaleUpDelay());
+    Assertions.assertEquals(Duration.millis(60000), baseOnly.getMinScaleDownDelay());
 
     // Only minScaleUpDelay set
     LagBasedAutoScalerConfig upOnly = new LagBasedAutoScalerConfig(
@@ -357,8 +357,8 @@ public class LagBasedAutoScalerConfigTest
         null,
         null
     );
-    Assert.assertEquals(Duration.millis(15000), upOnly.getMinScaleUpDelay());
-    Assert.assertEquals(Duration.millis(60000), upOnly.getMinScaleDownDelay());
+    Assertions.assertEquals(Duration.millis(15000), upOnly.getMinScaleUpDelay());
+    Assertions.assertEquals(Duration.millis(60000), upOnly.getMinScaleDownDelay());
 
     // Only minScaleDownDelay set
     LagBasedAutoScalerConfig downOnly = new LagBasedAutoScalerConfig(
@@ -382,8 +382,8 @@ public class LagBasedAutoScalerConfigTest
         null,
         null
     );
-    Assert.assertEquals(Duration.millis(60000), downOnly.getMinScaleUpDelay());
-    Assert.assertEquals(Duration.millis(30000), downOnly.getMinScaleDownDelay());
+    Assertions.assertEquals(Duration.millis(60000), downOnly.getMinScaleUpDelay());
+    Assertions.assertEquals(Duration.millis(30000), downOnly.getMinScaleDownDelay());
 
     // Both set: serde roundtrip preserves values
     LagBasedAutoScalerConfig bothSet = new LagBasedAutoScalerConfig(
@@ -407,13 +407,13 @@ public class LagBasedAutoScalerConfigTest
         null,
         null
     );
-    Assert.assertEquals(Duration.millis(15000), bothSet.getMinScaleUpDelay());
-    Assert.assertEquals(Duration.millis(30000), bothSet.getMinScaleDownDelay());
+    Assertions.assertEquals(Duration.millis(15000), bothSet.getMinScaleUpDelay());
+    Assertions.assertEquals(Duration.millis(30000), bothSet.getMinScaleDownDelay());
     LagBasedAutoScalerConfig roundTripped = OBJECT_MAPPER.readValue(
         OBJECT_MAPPER.writeValueAsString(bothSet),
         LagBasedAutoScalerConfig.class
     );
-    Assert.assertEquals(bothSet, roundTripped);
+    Assertions.assertEquals(bothSet, roundTripped);
   }
 
   @Test
@@ -424,9 +424,9 @@ public class LagBasedAutoScalerConfigTest
     // both getMinScaleUpDelay() and getMinScaleDownDelay() should fall back to it.
     String json = "{\"taskCountMax\":10,\"taskCountMin\":1,\"minTriggerScaleActionFrequencyMillis\":45000}";
     LagBasedAutoScalerConfig config = OBJECT_MAPPER.readValue(json, LagBasedAutoScalerConfig.class);
-    Assert.assertEquals(45000L, config.getMinTriggerScaleActionFrequencyMillis());
-    Assert.assertEquals(Duration.millis(45000), config.getMinScaleUpDelay());
-    Assert.assertEquals(Duration.millis(45000), config.getMinScaleDownDelay());
+    Assertions.assertEquals(45000L, config.getMinTriggerScaleActionFrequencyMillis());
+    Assertions.assertEquals(Duration.millis(45000), config.getMinScaleUpDelay());
+    Assertions.assertEquals(Duration.millis(45000), config.getMinScaleDownDelay());
 
     // JSON with minTriggerScaleActionFrequencyMillis and only minScaleUpDelay:
     // getMinScaleUpDelay() should return the explicit value; getMinScaleDownDelay() falls back.
@@ -434,8 +434,8 @@ public class LagBasedAutoScalerConfigTest
                         + "\"minTriggerScaleActionFrequencyMillis\":45000,"
                         + "\"minScaleUpDelay\":\"PT10S\"}";
     LagBasedAutoScalerConfig configUpOnly = OBJECT_MAPPER.readValue(jsonUpOnly, LagBasedAutoScalerConfig.class);
-    Assert.assertEquals(Duration.standardSeconds(10), configUpOnly.getMinScaleUpDelay());
-    Assert.assertEquals(Duration.millis(45000), configUpOnly.getMinScaleDownDelay());
+    Assertions.assertEquals(Duration.standardSeconds(10), configUpOnly.getMinScaleUpDelay());
+    Assertions.assertEquals(Duration.millis(45000), configUpOnly.getMinScaleDownDelay());
   }
 
   @Test
@@ -451,9 +451,9 @@ public class LagBasedAutoScalerConfigTest
           "{\"taskCountMax\":10,\"taskCountMin\":1}",
           LagBasedAutoScalerConfig.class
       );
-      Assert.assertEquals(defaultMinTriggerMillis, config.getMinTriggerScaleActionFrequencyMillis());
-      Assert.assertEquals(Duration.millis(defaultMinTriggerMillis), config.getMinScaleUpDelay());
-      Assert.assertEquals(Duration.millis(defaultMinTriggerMillis), config.getMinScaleDownDelay());
+      Assertions.assertEquals(defaultMinTriggerMillis, config.getMinTriggerScaleActionFrequencyMillis());
+      Assertions.assertEquals(Duration.millis(defaultMinTriggerMillis), config.getMinScaleUpDelay());
+      Assertions.assertEquals(Duration.millis(defaultMinTriggerMillis), config.getMinScaleDownDelay());
       assertRoundTrips(config);
     }
 
@@ -464,9 +464,9 @@ public class LagBasedAutoScalerConfigTest
           "{\"taskCountMax\":10,\"taskCountMin\":1,\"minTriggerScaleActionFrequencyMillis\":900000}",
           LagBasedAutoScalerConfig.class
       );
-      Assert.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
-      Assert.assertEquals(Duration.millis(900_000), config.getMinScaleUpDelay());
-      Assert.assertEquals(Duration.millis(900_000), config.getMinScaleDownDelay());
+      Assertions.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
+      Assertions.assertEquals(Duration.millis(900_000), config.getMinScaleUpDelay());
+      Assertions.assertEquals(Duration.millis(900_000), config.getMinScaleDownDelay());
       assertRoundTrips(config);
     }
 
@@ -477,9 +477,9 @@ public class LagBasedAutoScalerConfigTest
           + "\"minScaleUpDelay\":\"PT2M\",\"minScaleDownDelay\":\"PT15M\"}",
           LagBasedAutoScalerConfig.class
       );
-      Assert.assertEquals(defaultMinTriggerMillis, config.getMinTriggerScaleActionFrequencyMillis());
-      Assert.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
-      Assert.assertEquals(Duration.standardMinutes(15), config.getMinScaleDownDelay());
+      Assertions.assertEquals(defaultMinTriggerMillis, config.getMinTriggerScaleActionFrequencyMillis());
+      Assertions.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
+      Assertions.assertEquals(Duration.standardMinutes(15), config.getMinScaleDownDelay());
       assertRoundTrips(config);
     }
 
@@ -492,9 +492,9 @@ public class LagBasedAutoScalerConfigTest
           + "\"minScaleUpDelay\":\"PT2M\",\"minScaleDownDelay\":\"PT15M\"}",
           LagBasedAutoScalerConfig.class
       );
-      Assert.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
-      Assert.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
-      Assert.assertEquals(Duration.standardMinutes(15), config.getMinScaleDownDelay());
+      Assertions.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
+      Assertions.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
+      Assertions.assertEquals(Duration.standardMinutes(15), config.getMinScaleDownDelay());
       assertRoundTrips(config);
     }
 
@@ -506,9 +506,9 @@ public class LagBasedAutoScalerConfigTest
           + "\"minScaleUpDelay\":\"PT2M\"}",
           LagBasedAutoScalerConfig.class
       );
-      Assert.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
-      Assert.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
-      Assert.assertEquals(Duration.millis(900_000), config.getMinScaleDownDelay());
+      Assertions.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
+      Assertions.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
+      Assertions.assertEquals(Duration.millis(900_000), config.getMinScaleDownDelay());
       assertRoundTrips(config);
     }
 
@@ -520,9 +520,9 @@ public class LagBasedAutoScalerConfigTest
           + "\"minScaleDownDelay\":\"PT15M\"}",
           LagBasedAutoScalerConfig.class
       );
-      Assert.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
-      Assert.assertEquals(Duration.millis(900_000), config.getMinScaleUpDelay());
-      Assert.assertEquals(Duration.standardMinutes(15), config.getMinScaleDownDelay());
+      Assertions.assertEquals(900_000L, config.getMinTriggerScaleActionFrequencyMillis());
+      Assertions.assertEquals(Duration.millis(900_000), config.getMinScaleUpDelay());
+      Assertions.assertEquals(Duration.standardMinutes(15), config.getMinScaleDownDelay());
       assertRoundTrips(config);
     }
 
@@ -533,9 +533,9 @@ public class LagBasedAutoScalerConfigTest
           "{\"taskCountMax\":10,\"taskCountMin\":1,\"minScaleUpDelay\":\"PT2M\"}",
           LagBasedAutoScalerConfig.class
       );
-      Assert.assertEquals(defaultMinTriggerMillis, config.getMinTriggerScaleActionFrequencyMillis());
-      Assert.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
-      Assert.assertEquals(Duration.millis(defaultMinTriggerMillis), config.getMinScaleDownDelay());
+      Assertions.assertEquals(defaultMinTriggerMillis, config.getMinTriggerScaleActionFrequencyMillis());
+      Assertions.assertEquals(Duration.standardMinutes(2), config.getMinScaleUpDelay());
+      Assertions.assertEquals(Duration.millis(defaultMinTriggerMillis), config.getMinScaleDownDelay());
       assertRoundTrips(config);
     }
   }
@@ -546,7 +546,7 @@ public class LagBasedAutoScalerConfigTest
         OBJECT_MAPPER.writeValueAsString(config),
         LagBasedAutoScalerConfig.class
     );
-    Assert.assertEquals(config, roundTripped);
+    Assertions.assertEquals(config, roundTripped);
   }
 
   @Test
@@ -595,7 +595,7 @@ public class LagBasedAutoScalerConfigTest
         0.5
     );
 
-    Assert.assertNotEquals(config1, config2);
-    Assert.assertNotEquals(config1.hashCode(), config2.hashCode());
+    Assertions.assertNotEquals(config1, config2);
+    Assertions.assertNotEquals(config1.hashCode(), config2.hashCode());
   }
 }


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@druid.apache.org
For additional commands, e-mail: commits-help@druid.apache.org