diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterFailoverWithProceduresTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterFailoverWithProceduresTestBase.java index f275d628e1a9..d68a1d4c35a0 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterFailoverWithProceduresTestBase.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterFailoverWithProceduresTestBase.java @@ -23,8 +23,8 @@ import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; -import org.junit.AfterClass; -import org.junit.BeforeClass; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -35,7 +35,7 @@ public abstract class MasterFailoverWithProceduresTestBase { protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.getConfiguration().setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); StartTestingClusterOption option = StartTestingClusterOption.builder().numMasters(2).build(); @@ -46,7 +46,7 @@ public static void setUp() throws Exception { ProcedureTestingUtility.setKillBeforeStoreUpdate(procExec, false); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java index 70d89e7f0975..715c6951ae46 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java @@ -18,9 +18,9 @@ package org.apache.hadoop.hbase.master.procedure; import static org.apache.hadoop.hbase.regionserver.storefiletracker.StoreFileTrackerFactory.TRACKER_IMPL; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.List; @@ -201,13 +201,13 @@ public static void validateTableCreation(final HMaster master, final TableName t List unwantedRegionDirs = FSUtils.getRegionDirs(fs, tableDir); for (int i = 0; i < regions.length; ++i) { Path regionDir = new Path(tableDir, regions[i].getEncodedName()); - assertTrue(regions[i] + " region dir does not exist", fs.exists(regionDir)); + assertTrue(fs.exists(regionDir), regions[i] + " region dir does not exist"); assertTrue(unwantedRegionDirs.remove(regionDir)); List allFamilyDirs = FSUtils.getFamilyDirs(fs, regionDir); for (int j = 0; j < family.length; ++j) { final Path familyDir = new Path(regionDir, family[j]); if (hasFamilyDirs) { - assertTrue(family[j] + " family dir does not exist", fs.exists(familyDir)); + assertTrue(fs.exists(familyDir), family[j] + " family dir does not exist"); assertTrue(allFamilyDirs.remove(familyDir)); } else { // TODO: WARN: Modify Table/Families does not create a family dir @@ -217,9 +217,9 @@ public static void validateTableCreation(final HMaster master, final TableName t allFamilyDirs.remove(familyDir); } } - assertTrue("found extraneous families: " + allFamilyDirs, allFamilyDirs.isEmpty()); + assertTrue(allFamilyDirs.isEmpty(), "found extraneous families: " + allFamilyDirs); } - assertTrue("found extraneous regions: " + unwantedRegionDirs, unwantedRegionDirs.isEmpty()); + assertTrue(unwantedRegionDirs.isEmpty(), "found extraneous regions: " + unwantedRegionDirs); LOG.debug("Table directory layout is as expected."); // check meta @@ -228,10 +228,10 @@ public static void validateTableCreation(final HMaster master, final TableName t // check htd TableDescriptor htd = master.getTableDescriptors().get(tableName); - assertTrue("table descriptor not found", htd != null); + assertTrue(htd != null, "table descriptor not found"); for (int i = 0; i < family.length; ++i) { - assertTrue("family not found " + family[i], - htd.getColumnFamily(Bytes.toBytes(family[i])) != null); + assertTrue(htd.getColumnFamily(Bytes.toBytes(family[i])) != null, + "family not found " + family[i]); } assertEquals(family.length, htd.getColumnFamilyCount()); @@ -254,7 +254,7 @@ public static void validateTableDeletion(final HMaster master, final TableName t assertEquals(0, countMetaRegions(master, tableName)); // check htd - assertTrue("found htd of deleted table", master.getTableDescriptors().get(tableName) == null); + assertTrue(master.getTableDescriptors().get(tableName) == null, "found htd of deleted table"); } private static int countMetaRegions(final HMaster master, final TableName tableName) @@ -328,7 +328,7 @@ public static void validateColumnFamilyDeletion(final HMaster master, final Tabl CommonFSUtils.getTableDir(master.getMasterFileSystem().getRootDir(), tableName); for (Path regionDir : FSUtils.getRegionDirs(fs, tableDir)) { final Path familyDir = new Path(regionDir, family); - assertFalse(family + " family dir should not exist", fs.exists(familyDir)); + assertFalse(fs.exists(familyDir), family + " family dir should not exist"); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java index 3a161bac6872..7f6286e19805 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java @@ -17,12 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import java.util.stream.Stream; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableExistsException; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; @@ -39,30 +38,38 @@ import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; -import org.junit.After; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestCloneSnapshotProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCloneSnapshotProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestCloneSnapshotProcedure.class); protected final byte[] CF = Bytes.toBytes("cf1"); private static SnapshotProtos.SnapshotDescription snapshot = null; - @After + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } + + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } + + @AfterEach @Override public void tearDown() throws Exception { super.tearDown(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedureFileBasedSFT.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedureFileBasedSFT.java index ff2d9fc09ecc..313c4025c15f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedureFileBasedSFT.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedureFileBasedSFT.java @@ -20,24 +20,14 @@ import static org.apache.hadoop.hbase.regionserver.storefiletracker.StoreFileTrackerFactory.TRACKER_IMPL; import static org.apache.hadoop.hbase.regionserver.storefiletracker.StoreFileTrackerFactory.Trackers.FILE; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestCloneSnapshotProcedureFileBasedSFT extends TestCloneSnapshotProcedure { - - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCloneSnapshotProcedureFileBasedSFT.class); - - @BeforeClass - public static void setupCluster() throws Exception { + static { UTIL.getConfiguration().set(TRACKER_IMPL, FILE.name()); - UTIL.getConfiguration().setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); - UTIL.startMiniCluster(1); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateDeleteTableProcedureWithRetry.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateDeleteTableProcedureWithRetry.java index 3491aa639844..e1ceb6aabf02 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateDeleteTableProcedureWithRetry.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateDeleteTableProcedureWithRetry.java @@ -17,9 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.io.IOException; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; @@ -31,18 +33,14 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.ModifyRegionUtils; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestCreateDeleteTableProcedureWithRetry { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCreateDeleteTableProcedureWithRetry.class); private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -51,7 +49,7 @@ public class TestCreateDeleteTableProcedureWithRetry { private static final String CF = "cf"; - @BeforeClass + @BeforeAll public static void setUp() throws Exception { Configuration conf = UTIL.getConfiguration(); conf.set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY, @@ -59,7 +57,7 @@ public static void setUp() throws Exception { UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } @@ -73,7 +71,7 @@ public void testCreateDeleteTableRetry() throws IOException { CreateTableProcedure createProc = new CreateTableProcedure(procExec.getEnvironment(), htd, regions); ProcedureTestingUtility.submitAndWait(procExec, createProc); - Assert.assertTrue(UTIL.getAdmin().tableExists(TABLE_NAME)); + assertTrue(UTIL.getAdmin().tableExists(TABLE_NAME)); MasterProcedureTestingUtility.validateTableCreation(UTIL.getMiniHBaseCluster().getMaster(), TABLE_NAME, regions, CF); @@ -81,7 +79,7 @@ public void testCreateDeleteTableRetry() throws IOException { DeleteTableProcedure deleteProc = new DeleteTableProcedure(procExec.getEnvironment(), TABLE_NAME); ProcedureTestingUtility.submitAndWait(procExec, deleteProc); - Assert.assertFalse(UTIL.getAdmin().tableExists(TABLE_NAME)); + assertFalse(UTIL.getAdmin().tableExists(TABLE_NAME)); MasterProcedureTestingUtility.validateTableDeletion(UTIL.getMiniHBaseCluster().getMaster(), TABLE_NAME); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java index 384be5613006..d8481039e789 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java @@ -17,13 +17,12 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.NamespaceExistException; @@ -34,23 +33,19 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestCreateNamespaceProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCreateNamespaceProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestCreateNamespaceProcedure.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -59,13 +54,13 @@ private static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); @@ -74,12 +69,12 @@ public static void cleanupTest() throws Exception { } } - @Before + @BeforeEach public void setup() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); } - @After + @AfterEach public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableNoRegionServer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableNoRegionServer.java index 4fcccf1fbf4b..5119133e7b0a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableNoRegionServer.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableNoRegionServer.java @@ -23,7 +23,6 @@ import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.StartTestingClusterOption; import org.apache.hadoop.hbase.TableName; @@ -40,23 +39,19 @@ import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.metrics2.impl.JmxCacheBuster; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CreateTableState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestCreateTableNoRegionServer { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCreateTableNoRegionServer.class); - private static final Logger LOG = LoggerFactory.getLogger(TestCreateTableNoRegionServer.class); private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -113,7 +108,7 @@ public AssignmentManager getAssignmentManager() { } } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.startMiniCluster( StartTestingClusterOption.builder().masterClass(HMasterForTest.class).build()); @@ -126,7 +121,7 @@ public static void setUp() throws Exception { JmxCacheBuster.stop(); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java index 0bb54cc190e3..6a98f7739c83 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java @@ -18,17 +18,17 @@ package org.apache.hadoop.hbase.master.procedure; import static org.apache.hadoop.hbase.regionserver.storefiletracker.StoreFileTrackerFactory.TRACKER_IMPL; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.DoNotRetryIOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.TableExistsException; import org.apache.hadoop.hbase.TableName; @@ -50,37 +50,48 @@ import org.apache.hadoop.hbase.util.FSUtils; import org.apache.hadoop.hbase.util.ModifyRegionUtils; import org.apache.hadoop.hbase.util.TableDescriptorChecker; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestCreateTableProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCreateTableProcedure.class); - private static final String F1 = "f1"; private static final String F2 = "f2"; + private String testMethodName; + + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } - @Rule - public TestName name = new TestName(); + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } + + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } @Test public void testSimpleCreate() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final byte[][] splitKeys = null; testSimpleCreate(tableName, splitKeys); } @Test public void testSimpleCreateWithSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final byte[][] splitKeys = new byte[][] { Bytes.toBytes("a"), Bytes.toBytes("b"), Bytes.toBytes("c") }; testSimpleCreate(tableName, splitKeys); @@ -94,7 +105,7 @@ private void testSimpleCreate(final TableName tableName, byte[][] splitKeys) thr @Test public void testCreateWithTrackImpl() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); ProcedureExecutor procExec = getMasterProcedureExecutor(); TableDescriptor htd = MasterProcedureTestingUtility.createHTD(tableName, F1); String trackerName = StoreFileTrackerForTest.class.getName(); @@ -112,7 +123,7 @@ public void testCreateWithFileBasedStoreTrackerImpl() throws Exception { ProcedureExecutor procExec = getMasterProcedureExecutor(); procExec.getEnvironment().getMasterConfiguration().set(StoreFileTrackerFactory.TRACKER_IMPL, StoreFileTrackerFactory.Trackers.FILE.name()); - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); TableDescriptor htd = MasterProcedureTestingUtility.createHTD(tableName, F1); RegionInfo[] regions = ModifyRegionUtils.createRegionInfos(htd, null); long procId = ProcedureTestingUtility.submitAndWait(procExec, @@ -125,7 +136,7 @@ public void testCreateWithFileBasedStoreTrackerImpl() throws Exception { @Test public void testCreateWithoutColumnFamily() throws Exception { final ProcedureExecutor procExec = getMasterProcedureExecutor(); - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); // create table with 0 families will fail final TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(MasterProcedureTestingUtility.createHTD(tableName)); @@ -140,13 +151,13 @@ public void testCreateWithoutColumnFamily() throws Exception { final Procedure result = procExec.getResult(procId); assertEquals(true, result.isFailed()); Throwable cause = ProcedureTestingUtility.getExceptionCause(result); - assertTrue("expected DoNotRetryIOException, got " + cause, - cause instanceof DoNotRetryIOException); + assertTrue(cause instanceof DoNotRetryIOException, + "expected DoNotRetryIOException, got " + cause); } - @Test(expected = TableExistsException.class) + @Test public void testCreateExisting() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); final TableDescriptor htd = MasterProcedureTestingUtility.createHTD(tableName, "f"); final RegionInfo[] regions = ModifyRegionUtils.createRegionInfos(htd, null); @@ -164,12 +175,12 @@ public void testCreateExisting() throws Exception { ProcedureTestingUtility.assertProcNotFailed(procExec.getResult(procId1)); ProcedureTestingUtility.waitProcedure(procExec, procId2); - latch2.await(); + assertThrows(TableExistsException.class, latch2::await); } @Test public void testRecoveryAndDoubleExecution() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); // create the table final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -189,14 +200,14 @@ public void testRecoveryAndDoubleExecution() throws Exception { @Test public void testRollbackAndDoubleExecution() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testRollbackAndDoubleExecution(TableDescriptorBuilder .newBuilder(MasterProcedureTestingUtility.createHTD(tableName, F1, F2))); } @Test public void testRollbackAndDoubleExecutionOnMobTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); TableDescriptor htd = MasterProcedureTestingUtility.createHTD(tableName, F1, F2); TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(htd).modifyColumnFamily(ColumnFamilyDescriptorBuilder @@ -275,7 +286,7 @@ protected Flow executeFromState(MasterProcedureEnv env, @Test public void testOnHDFSFailure() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); // create the table final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -291,7 +302,7 @@ public void testOnHDFSFailure() throws Exception { @Test public void testCreateTableWithManyRegionReplication() throws IOException { final int EXCEED_MAX_REGION_REPLICATION = 0x10001; - TableName tableName = TableName.valueOf(name.getMethodName()); + TableName tableName = TableName.valueOf(testMethodName); ProcedureExecutor procExec = getMasterProcedureExecutor(); TableDescriptor tableWithManyRegionReplication = TableDescriptorBuilder.newBuilder(tableName) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedureMuitipleRegions.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedureMuitipleRegions.java index 081bbee4ecb5..0d61c9495c25 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedureMuitipleRegions.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedureMuitipleRegions.java @@ -17,37 +17,32 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestCreateTableProcedureMuitipleRegions { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCreateTableProcedureMuitipleRegions.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static final String F1 = "f1"; private static final String F2 = "f2"; - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableWithMasterFailover.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableWithMasterFailover.java index 90a4c16b5ac5..2042e7f6b503 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableWithMasterFailover.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableWithMasterFailover.java @@ -17,7 +17,6 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.TableDescriptor; @@ -26,19 +25,15 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.ModifyRegionUtils; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CreateTableState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestCreateTableWithMasterFailover extends MasterFailoverWithProceduresTestBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCreateTableWithMasterFailover.class); - // ========================================================================== // Test Create Table // ========================================================================== diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteColumnFamilyProcedureFromClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteColumnFamilyProcedureFromClient.java index ee9ccbf115b5..69b40b4777ba 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteColumnFamilyProcedureFromClient.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteColumnFamilyProcedureFromClient.java @@ -17,16 +17,16 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.fs.PathFilter; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.InvalidFamilyOperationException; @@ -40,22 +40,17 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.wal.WALSplitUtil; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; - -@Category({ MasterTests.class, MediumTests.class }) +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; + +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestDeleteColumnFamilyProcedureFromClient { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDeleteColumnFamilyProcedureFromClient.class); - private static final HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil(); private static final TableName TABLENAME = TableName.valueOf("column_family_handlers"); @@ -65,17 +60,17 @@ public class TestDeleteColumnFamilyProcedureFromClient { /** * Start up a mini cluster and put a small table of empty regions into it. */ - @BeforeClass + @BeforeAll public static void beforeAllTests() throws Exception { TEST_UTIL.startMiniCluster(2); } - @AfterClass + @AfterAll public static void afterAllTests() throws Exception { TEST_UTIL.shutdownMiniCluster(); } - @Before + @BeforeEach public void setup() throws IOException, InterruptedException { // Create a table of three families. This will assign a region. TEST_UTIL.createTable(TABLENAME, FAMILIES); @@ -92,7 +87,7 @@ public void setup() throws IOException, InterruptedException { TEST_UTIL.ensureSomeRegionServersAvailable(2); } - @After + @AfterEach public void cleanup() throws Exception { TEST_UTIL.deleteTable(TABLENAME); } @@ -257,7 +252,7 @@ public boolean accept(Path p) { try { // Test: delete again admin.deleteColumnFamily(TABLENAME, Bytes.toBytes(cfToDelete)); - Assert.fail("Delete a non-exist column family should fail"); + fail("Delete a non-exist column family should fail"); } catch (InvalidFamilyOperationException e) { // Expected. } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java index 6df3718327b2..153fe940bf97 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java @@ -17,13 +17,12 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.NamespaceNotFoundException; @@ -35,43 +34,41 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestDeleteNamespaceProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDeleteNamespaceProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestDeleteNamespaceProcedure.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } private static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); @@ -80,12 +77,12 @@ public static void cleanupTest() throws Exception { } } - @Before + @BeforeEach public void setup() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); } - @After + @AfterEach public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); for (TableDescriptor htd : UTIL.getAdmin().listTableDescriptors()) { @@ -147,8 +144,7 @@ public void testDeleteSystemNamespace() throws Exception { @Test public void testDeleteNonEmptyNamespace() throws Exception { final String namespaceName = "testDeleteNonExistNamespace"; - final TableName tableName = - TableName.valueOf("testDeleteNonExistNamespace:" + name.getMethodName()); + final TableName tableName = TableName.valueOf("testDeleteNonExistNamespace:" + testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); // create namespace createNamespaceForTesting(namespaceName); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedure.java index bdc7388fb5fa..7a604fd53950 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedure.java @@ -17,13 +17,13 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.TableNotDisabledException; import org.apache.hadoop.hbase.TableNotFoundException; @@ -34,52 +34,68 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestDeleteTableProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDeleteTableProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestDeleteTableProcedure.class); - @Rule - public TestName name = new TestName(); + private String testMethodName; + + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } - @Test(expected = TableNotFoundException.class) + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } + + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } + + @Test public void testDeleteNotExistentTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); - ProcedurePrepareLatch latch = new ProcedurePrepareLatch.CompatibilityLatch(); - long procId = ProcedureTestingUtility.submitAndWait(procExec, - new DeleteTableProcedure(procExec.getEnvironment(), tableName, latch)); - latch.await(); + assertThrows(TableNotFoundException.class, () -> { + ProcedurePrepareLatch latch = new ProcedurePrepareLatch.CompatibilityLatch(); + ProcedureTestingUtility.submitAndWait(procExec, + new DeleteTableProcedure(procExec.getEnvironment(), tableName, latch)); + latch.await(); + }); } - @Test(expected = TableNotDisabledException.class) + @Test public void testDeleteNotDisabledTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f"); - ProcedurePrepareLatch latch = new ProcedurePrepareLatch.CompatibilityLatch(); - long procId = ProcedureTestingUtility.submitAndWait(procExec, - new DeleteTableProcedure(procExec.getEnvironment(), tableName, latch)); - latch.await(); + assertThrows(TableNotDisabledException.class, () -> { + ProcedurePrepareLatch latch = new ProcedurePrepareLatch.CompatibilityLatch(); + ProcedureTestingUtility.submitAndWait(procExec, + new DeleteTableProcedure(procExec.getEnvironment(), tableName, latch)); + latch.await(); + }); } @Test public void testDeleteDeletedTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); RegionInfo[] regions = @@ -110,14 +126,14 @@ public void testDeleteDeletedTable() throws Exception { @Test public void testSimpleDelete() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final byte[][] splitKeys = null; testSimpleDelete(tableName, splitKeys); } @Test public void testSimpleDeleteWithSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final byte[][] splitKeys = new byte[][] { Bytes.toBytes("a"), Bytes.toBytes("b"), Bytes.toBytes("c") }; testSimpleDelete(tableName, splitKeys); @@ -125,17 +141,17 @@ public void testSimpleDeleteWithSplits() throws Exception { @Test public void testDeleteFromMeta() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); RegionInfo[] regions = MasterProcedureTestingUtility.createTable(getMasterProcedureExecutor(), tableName, null, "f1", "f2"); List regionsList = new ArrayList<>(); UTIL.getAdmin().disableTable(tableName); MasterProcedureEnv procedureEnv = getMasterProcedureExecutor().getEnvironment(); - assertNotNull("Table should be on TableDescriptors cache.", - procedureEnv.getMasterServices().getTableDescriptors().get(tableName)); + assertNotNull(procedureEnv.getMasterServices().getTableDescriptors().get(tableName), + "Table should be on TableDescriptors cache."); DeleteTableProcedure.deleteFromMeta(procedureEnv, tableName, regionsList); - assertNull("Table shouldn't be on TableDescriptors anymore.", - procedureEnv.getMasterServices().getTableDescriptors().get(tableName)); + assertNull(procedureEnv.getMasterServices().getTableDescriptors().get(tableName), + "Table shouldn't be on TableDescriptors anymore."); } private void testSimpleDelete(final TableName tableName, byte[][] splitKeys) throws Exception { @@ -153,7 +169,7 @@ private void testSimpleDelete(final TableName tableName, byte[][] splitKeys) thr @Test public void testRecoveryAndDoubleExecution() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); // create the table byte[][] splitKeys = null; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedureWithRecovery.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedureWithRecovery.java index e17fb5171050..e0c746d69cd2 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedureWithRecovery.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableProcedureWithRecovery.java @@ -17,10 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.SnapshotDescription; @@ -30,36 +29,42 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DeleteTableState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestDeleteTableProcedureWithRecovery extends TestTableDDLProcedureBase { + private String testMethodName; - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDeleteTableProcedureWithRecovery.class); - - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { // Enable recovery snapshots + TestTableDDLProcedureBase.setupConf(UTIL.getConfiguration()); UTIL.getConfiguration().setBoolean(HConstants.SNAPSHOT_BEFORE_DESTRUCTIVE_ACTION_ENABLED_KEY, true); - TestTableDDLProcedureBase.setupCluster(); + UTIL.startMiniCluster(1); + } + + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); } @Test public void testRecoverySnapshotRollback() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String[] families = new String[] { "f1", "f2" }; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -76,7 +81,7 @@ public void testRecoverySnapshotRollback() throws Exception { // Wait for procedure to complete (should fail) ProcedureTestingUtility.waitProcedure(procExec, procId); Procedure result = procExec.getResult(procId); - assertTrue("Procedure should have failed", result.isFailed()); + assertTrue(result.isFailed(), "Procedure should have failed"); // Verify no recovery snapshots remain after rollback boolean snapshotFound = false; @@ -86,13 +91,13 @@ public void testRecoverySnapshotRollback() throws Exception { break; } } - assertTrue("Recovery snapshot should have been cleaned up during rollback", !snapshotFound); + assertTrue(!snapshotFound, "Recovery snapshot should have been cleaned up during rollback"); } @Test public void testRecoverySnapshotAndRestore() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); - final TableName restoredTableName = TableName.valueOf(name.getMethodName() + "_restored"); + final TableName tableName = TableName.valueOf(testMethodName); + final TableName restoredTableName = TableName.valueOf(testMethodName + "_restored"); final String[] families = new String[] { "f1", "f2" }; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -119,7 +124,7 @@ public void testRecoverySnapshotAndRestore() throws Exception { break; } } - assertTrue("Recovery snapshot should exist", recoverySnapshotName != null); + assertTrue(recoverySnapshotName != null, "Recovery snapshot should exist"); // Restore from snapshot by cloning to a new table UTIL.getAdmin().cloneSnapshot(recoverySnapshotName, restoredTableName); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableWithMasterFailover.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableWithMasterFailover.java index 7375a40118aa..a37abb68d940 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableWithMasterFailover.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteTableWithMasterFailover.java @@ -17,26 +17,21 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DeleteTableState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestDeleteTableWithMasterFailover extends MasterFailoverWithProceduresTestBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDeleteTableWithMasterFailover.class); - // ========================================================================== // Test Delete Table // ========================================================================== diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableProcedure.java index 1e22a19b264c..2ec44e56da16 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableProcedure.java @@ -17,9 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.TableNotEnabledException; import org.apache.hadoop.hbase.procedure2.Procedure; @@ -28,30 +28,40 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.Assert; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestDisableTableProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDisableTableProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestDisableTableProcedure.class); + private String testMethodName; + + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } - @Rule - public TestName name = new TestName(); + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } + + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } @Test public void testDisableTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f1", "f2"); @@ -67,7 +77,7 @@ public void testDisableTable() throws Exception { @Test public void testDisableTableMultipleTimes() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f1", "f2"); @@ -108,7 +118,7 @@ public void testDisableTableMultipleTimes() throws Exception { long procId3 = procExec.submitProcedure( new DisableTableProcedure(procExec.getEnvironment(), tableName, false, prepareLatch)); prepareLatch.await(); - Assert.fail("Disable should throw exception through latch."); + fail("Disable should throw exception through latch."); } catch (TableNotEnabledException tnee) { // Expected LOG.debug("Disable failed with expected exception {}", tnee); @@ -130,7 +140,7 @@ public void testDisableTableMultipleTimes() throws Exception { @Test public void testRecoveryAndDoubleExecution() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); final byte[][] splitKeys = diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableWithMasterFailover.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableWithMasterFailover.java index 96a7a841d7e4..b29938796cc7 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableWithMasterFailover.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDisableTableWithMasterFailover.java @@ -17,26 +17,21 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DisableTableState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestDisableTableWithMasterFailover extends MasterFailoverWithProceduresTestBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestDisableTableWithMasterFailover.class); - // ========================================================================== // Test Disable Table // ========================================================================== diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java index e8a548a77769..e833f80b6732 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java @@ -17,9 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.TableNotDisabledException; import org.apache.hadoop.hbase.procedure2.Procedure; @@ -28,29 +28,40 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestEnableTableProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestEnableTableProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestEnableTableProcedure.class); + private String testMethodName; + + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } - @Rule - public TestName name = new TestName(); + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } + + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } @Test public void testEnableTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f1", "f2"); @@ -65,9 +76,9 @@ public void testEnableTable() throws Exception { MasterProcedureTestingUtility.validateTableIsEnabled(getMaster(), tableName); } - @Test(expected = TableNotDisabledException.class) + @Test public void testEnableNonDisabledTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f1", "f2"); @@ -87,12 +98,12 @@ public void testEnableNonDisabledTable() throws Exception { final ProcedurePrepareLatch prepareLatch = new ProcedurePrepareLatch.CompatibilityLatch(); procExec.submitProcedure( new EnableTableProcedure(procExec.getEnvironment(), tableName, prepareLatch)); - prepareLatch.await(); + assertThrows(TableNotDisabledException.class, prepareLatch::await); } @Test public void testRecoveryAndDoubleExecution() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); final byte[][] splitKeys = @@ -115,7 +126,7 @@ public void testRecoveryAndDoubleExecution() throws Exception { @Test public void testRollbackAndDoubleExecution() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); final byte[][] splitKeys = diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableWithMasterFailover.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableWithMasterFailover.java index 5b9aa044d14e..8a511647e736 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableWithMasterFailover.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableWithMasterFailover.java @@ -17,26 +17,21 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.EnableTableState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestEnableTableWithMasterFailover extends MasterFailoverWithProceduresTestBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestEnableTableWithMasterFailover.class); - // ========================================================================== // Test Enable Table // ========================================================================== diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFastFailOnProcedureNotRegistered.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFastFailOnProcedureNotRegistered.java index fbe909c358e7..15545fad75a6 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFastFailOnProcedureNotRegistered.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFastFailOnProcedureNotRegistered.java @@ -17,30 +17,39 @@ */ package org.apache.hadoop.hbase.master.procedure; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.io.IOException; import java.util.HashMap; import java.util.Map; import org.apache.hadoop.hbase.DoNotRetryIOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestFastFailOnProcedureNotRegistered extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFastFailOnProcedureNotRegistered.class); + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } + + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } - @Test(expected = DoNotRetryIOException.class) + @Test public void testFastFailOnProcedureNotRegistered() throws IOException { Admin admin = UTIL.getAdmin(); Map props = new HashMap(); - admin.execProcedure("fake1", "fake2", props); + assertThrows(DoNotRetryIOException.class, () -> admin.execProcedure("fake1", "fake2", props)); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedure.java index 9da19aae77c8..419e2e577090 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedure.java @@ -17,26 +17,22 @@ */ package org.apache.hadoop.hbase.master.procedure; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.io.IOException; import java.util.Arrays; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableNotEnabledException; import org.apache.hadoop.hbase.TableNotFoundException; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.Assert; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestFlushTableProcedure extends TestFlushTableProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFlushTableProcedure.class); - @Test public void testSimpleFlush() throws IOException { assertTableMemStoreNotEmpty(); @@ -48,9 +44,9 @@ public void testSimpleFlush() throws IOException { public void testFlushTableExceptionally() throws IOException { Admin admin = TEST_UTIL.getAdmin(); admin.disableTable(TABLE_NAME); - Assert.assertThrows(TableNotEnabledException.class, () -> admin.flush(TABLE_NAME)); + assertThrows(TableNotEnabledException.class, () -> admin.flush(TABLE_NAME)); admin.deleteTable(TABLE_NAME); - Assert.assertThrows(TableNotFoundException.class, () -> admin.flush(TABLE_NAME)); + assertThrows(TableNotFoundException.class, () -> admin.flush(TABLE_NAME)); } @Test diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureBase.java index 9e3eee3c7044..e423a55ce439 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureBase.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureBase.java @@ -17,6 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; @@ -26,9 +29,8 @@ import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.RegionSplitter; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; public class TestFlushTableProcedureBase { @@ -39,7 +41,7 @@ public class TestFlushTableProcedureBase { protected byte[] FAMILY2; protected byte[] FAMILY3; - @Before + @BeforeEach public void setup() throws Exception { TEST_UTIL = new HBaseTestingUtil(); addConfiguration(TEST_UTIL.getConfiguration()); @@ -65,28 +67,28 @@ protected void addConfiguration(Configuration config) { protected void assertTableMemStoreNotEmpty() { long totalSize = TEST_UTIL.getHBaseCluster().getRegions(TABLE_NAME).stream() .mapToLong(HRegion::getMemStoreDataSize).sum(); - Assert.assertTrue(totalSize > 0); + assertTrue(totalSize > 0); } protected void assertTableMemStoreEmpty() { long totalSize = TEST_UTIL.getHBaseCluster().getRegions(TABLE_NAME).stream() .mapToLong(HRegion::getMemStoreDataSize).sum(); - Assert.assertEquals(0, totalSize); + assertEquals(0, totalSize); } protected void assertColumnFamilyMemStoreNotEmpty(byte[] columnFamily) { long totalSize = TEST_UTIL.getHBaseCluster().getRegions(TABLE_NAME).stream() .mapToLong(r -> r.getStore(columnFamily).getMemStoreSize().getDataSize()).sum(); - Assert.assertTrue(totalSize > 0); + assertTrue(totalSize > 0); } protected void assertColumnFamilyMemStoreEmpty(byte[] columnFamily) { long totalSize = TEST_UTIL.getHBaseCluster().getRegions(TABLE_NAME).stream() .mapToLong(r -> r.getStore(columnFamily).getMemStoreSize().getDataSize()).sum(); - Assert.assertEquals(0, totalSize); + assertEquals(0, totalSize); } - @After + @AfterEach public void teardown() throws Exception { if (TEST_UTIL.getHBaseCluster().getMaster() != null) { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate( diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureMasterRestarts.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureMasterRestarts.java index 0e7af051d342..9ad265e75d22 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureMasterRestarts.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureMasterRestarts.java @@ -18,7 +18,6 @@ package org.apache.hadoop.hbase.master.procedure; import java.io.IOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.master.RegionState; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; @@ -26,17 +25,13 @@ import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestFlushTableProcedureMasterRestarts extends TestFlushTableProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFlushTableProcedureMasterRestarts.class); - @Test public void testMasterRestarts() throws IOException { assertTableMemStoreNotEmpty(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureWithDoNotSupportFlushTableMaster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureWithDoNotSupportFlushTableMaster.java index ecb433509bf9..652a0e314004 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureWithDoNotSupportFlushTableMaster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestFlushTableProcedureWithDoNotSupportFlushTableMaster.java @@ -22,24 +22,19 @@ import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.DoNotRetryIOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestFlushTableProcedureWithDoNotSupportFlushTableMaster extends TestFlushTableProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFlushTableProcedureWithDoNotSupportFlushTableMaster.class); - @Override protected void addConfiguration(Configuration config) { super.addConfiguration(config); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestHBCKSCP.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestHBCKSCP.java index a878af785783..34ea724d599e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestHBCKSCP.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestHBCKSCP.java @@ -17,19 +17,20 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static junit.framework.TestCase.assertFalse; -import static junit.framework.TestCase.assertNotNull; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.List; import java.util.NoSuchElementException; import java.util.Objects; import java.util.concurrent.TimeUnit; +import java.util.stream.Stream; import org.apache.hadoop.hbase.CatalogFamilyFormat; -import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate; import org.apache.hadoop.hbase.HBaseServerBase; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.HConstants; @@ -37,7 +38,7 @@ import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.SingleProcessHBaseCluster; import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.TableNameTestRule; +import org.apache.hadoop.hbase.TableNameTestExtension; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Table; @@ -51,12 +52,10 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.JVMClusterUtil; import org.apache.hadoop.hbase.util.Pair; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.TestTemplate; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.provider.Arguments; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -69,16 +68,14 @@ * Test of the HBCK-version of SCP. The HBCKSCP is an SCP only it reads hbase:meta for list of * Regions that were on the server-to-process rather than consult Master in-memory-state. */ -@Category({ MasterTests.class, LargeTests.class }) -@RunWith(Parameterized.class) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) +@HBaseParameterizedTestTemplate(name = "replicas:{0} scheduler:{1} selector:{2}") public class TestHBCKSCP extends TestSCPBase { private static final Logger LOG = LoggerFactory.getLogger(TestHBCKSCP.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestHBCKSCP.class); - @Rule - public TableNameTestRule tableNameTestRule = new TableNameTestRule(); + @RegisterExtension + public TableNameTestExtension tableNameTestExtension = new TableNameTestExtension(); private final int replicas; private final HBCKSCPScheduler hbckscpScheduler; @@ -91,16 +88,15 @@ public TestHBCKSCP(final int replicas, final HBCKSCPScheduler hbckscpScheduler, this.regionSelector = regionSelector; } - @Parameterized.Parameters(name = "replicas:{0} scheduler:{1} selector:{2}") - public static Object[][] params() { - return new Object[][] { - { 1, new ScheduleServerCrashProcedure(), new PrimaryNotMetaRegionSelector() }, - { 3, new ScheduleServerCrashProcedure(), new ReplicaNonMetaRegionSelector() }, - { 1, new ScheduleSCPsForUnknownServers(), new PrimaryNotMetaRegionSelector() }, - { 3, new ScheduleSCPsForUnknownServers(), new ReplicaNonMetaRegionSelector() } }; + public static Stream parameters() { + return Stream.of( + Arguments.of(1, new ScheduleServerCrashProcedure(), new PrimaryNotMetaRegionSelector()), + Arguments.of(3, new ScheduleServerCrashProcedure(), new ReplicaNonMetaRegionSelector()), + Arguments.of(1, new ScheduleSCPsForUnknownServers(), new PrimaryNotMetaRegionSelector()), + Arguments.of(3, new ScheduleSCPsForUnknownServers(), new ReplicaNonMetaRegionSelector())); } - @Test + @TestTemplate public void test() throws Exception { // we are about to do one for it? SingleProcessHBaseCluster cluster = this.util.getHBaseCluster(); @@ -109,12 +105,12 @@ public void test() throws Exception { assertEquals(RS_COUNT, cluster.getLiveRegionServerThreads().size()); int count; - try (Table table = createTable(tableNameTestRule.getTableName())) { + try (Table table = createTable(tableNameTestExtension.getTableName())) { // Load the table with a bit of data so some logs to split and some edits in each region. this.util.loadTable(table, HBaseTestingUtil.COLUMNS[0]); count = HBaseTestingUtil.countRows(table); } - assertTrue("expected some rows", count > 0); + assertTrue(count > 0, "expected some rows"); // Make the test easier by not working on server hosting meta... // Find another RS. Purge it from Master memory w/o running SCP (if diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestIgnoreUnknownFamily.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestIgnoreUnknownFamily.java index 3e0f0379f0b1..e332e0fc9e77 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestIgnoreUnknownFamily.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestIgnoreUnknownFamily.java @@ -23,7 +23,6 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; @@ -38,45 +37,44 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.FSUtils; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; /** * Testcase for HBASE-22632 */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestIgnoreUnknownFamily { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestIgnoreUnknownFamily.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static final byte[] FAMILY = Bytes.toBytes("cf"); private static final byte[] UNKNOWN_FAMILY = Bytes.toBytes("wrong_cf"); + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } - @After + @AfterEach public void tearDownAfterTest() throws IOException { Admin admin = UTIL.getAdmin(); for (TableName tableName : admin.listTableNames()) { @@ -99,7 +97,7 @@ private void addStoreFileToKnownFamily(RegionInfo region) throws IOException { @Test public void testSplit() throws IOException, InterruptedException, ExecutionException, TimeoutException { - TableName tableName = TableName.valueOf(name.getMethodName()); + TableName tableName = TableName.valueOf(testMethodName); Admin admin = UTIL.getAdmin(); admin.createTable(TableDescriptorBuilder.newBuilder(tableName) .setColumnFamily(ColumnFamilyDescriptorBuilder.of(FAMILY)).build()); @@ -111,7 +109,7 @@ public void testSplit() @Test public void testMerge() throws IOException, InterruptedException, ExecutionException, TimeoutException { - TableName tableName = TableName.valueOf(name.getMethodName()); + TableName tableName = TableName.valueOf(testMethodName); Admin admin = UTIL.getAdmin(); admin.createTable( TableDescriptorBuilder.newBuilder(tableName) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestLogRollProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestLogRollProcedure.java index 1b587097ddad..e42bf968a47a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestLogRollProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestLogRollProcedure.java @@ -19,11 +19,10 @@ import static org.apache.hadoop.hbase.procedure2.RemoteProcedureDispatcher.DISPATCH_DELAY_CONF_KEY; import static org.apache.hadoop.hbase.procedure2.RemoteProcedureDispatcher.DISPATCH_MAX_QUEUE_SIZE_CONF_KEY; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.SingleProcessHBaseCluster; @@ -31,29 +30,26 @@ import org.apache.hadoop.hbase.regionserver.HRegionServer; import org.apache.hadoop.hbase.regionserver.wal.AbstractFSWAL; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; - -@Category(MediumTests.class) -public class TestLogRollProcedure { +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestLogRollProcedure.class); +@Tag(MediumTests.TAG) +public class TestLogRollProcedure { + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } private final static HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil(); private Configuration conf; - @Before + @BeforeEach public void setUp() throws Exception { conf = TEST_UTIL.getConfiguration(); conf.set(DISPATCH_DELAY_CONF_KEY, "2000"); @@ -61,7 +57,7 @@ public void setUp() throws Exception { TEST_UTIL.startMiniCluster(2); } - @After + @AfterEach public void tearDown() throws Exception { TEST_UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestManageTableErasureCodingPolicy.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestManageTableErasureCodingPolicy.java index 34a77229dcad..59c80feae235 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestManageTableErasureCodingPolicy.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestManageTableErasureCodingPolicy.java @@ -23,7 +23,7 @@ import static org.hamcrest.Matchers.greaterThan; import static org.hamcrest.Matchers.notNullValue; import static org.hamcrest.Matchers.nullValue; -import static org.junit.Assert.assertThrows; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.io.IOException; import java.util.function.Function; @@ -31,7 +31,6 @@ import org.apache.hadoop.fs.LocatedFileStatus; import org.apache.hadoop.fs.Path; import org.apache.hadoop.fs.RemoteIterator; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; @@ -51,20 +50,16 @@ import org.apache.hadoop.hbase.util.TableDescriptorChecker; import org.apache.hadoop.hdfs.DistributedFileSystem; import org.apache.hadoop.hdfs.protocol.ErasureCodingPolicy; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestManageTableErasureCodingPolicy { - - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestManageTableErasureCodingPolicy.class); private static final Logger LOG = LoggerFactory.getLogger(TestManageTableErasureCodingPolicy.class); @@ -78,7 +73,7 @@ public class TestManageTableErasureCodingPolicy { TableDescriptorBuilder.newBuilder(EC_TABLE).setErasureCodingPolicy("XOR-2-1-1024k") .setColumnFamily(ColumnFamilyDescriptorBuilder.of(FAMILY)).build(); - @BeforeClass + @BeforeAll public static void beforeClass() throws Exception { // enable because we are testing the checks below UTIL.getConfiguration().setBoolean(TableDescriptorChecker.TABLE_SANITY_CHECKS, true); @@ -92,7 +87,7 @@ public static void beforeClass() throws Exception { UTIL.flush(); } - @AfterClass + @AfterAll public static void afterClass() throws Exception { UTIL.shutdownMiniCluster(); UTIL.shutdownMiniDFSCluster(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterObserverPostCalls.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterObserverPostCalls.java index 767441915849..7a5a57c7d180 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterObserverPostCalls.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterObserverPostCalls.java @@ -17,15 +17,14 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.util.Optional; import java.util.concurrent.atomic.AtomicInteger; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.CoprocessorEnvironment; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.TableName; @@ -43,11 +42,10 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -55,17 +53,14 @@ * Tests class that validates that "post" observer hook methods are only invoked when the operation * was successful. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestMasterObserverPostCalls { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMasterObserverPostCalls.class); - private static final Logger LOG = LoggerFactory.getLogger(TestMasterObserverPostCalls.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(1); @@ -77,7 +72,7 @@ private static void setupConf(Configuration conf) { MasterObserverForTest.class.getName()); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); @@ -162,8 +157,8 @@ public void testPostDeleteNamespace() throws IOException { // Pass } int postCount = observer.postHookCalls.get(); - assertEquals("Expected no invocations of postDeleteNamespace when the operation fails", - preCount, postCount); + assertEquals(preCount, postCount, + "Expected no invocations of postDeleteNamespace when the operation fails"); // Disable and delete the table so that we can delete the NS. admin.disableTable(tn1); @@ -173,7 +168,7 @@ public void testPostDeleteNamespace() throws IOException { preCount = observer.postHookCalls.get(); admin.deleteNamespace(ns); postCount = observer.postHookCalls.get(); - assertEquals("Expected 1 invocation of postDeleteNamespace", preCount + 1, postCount); + assertEquals(preCount + 1, postCount, "Expected 1 invocation of postDeleteNamespace"); } @Test @@ -195,15 +190,15 @@ public void testPostModifyNamespace() throws IOException { // Pass } int postCount = observer.postHookCalls.get(); - assertEquals("Expected no invocations of postModifyNamespace when the operation fails", - preCount, postCount); + assertEquals(preCount, postCount, + "Expected no invocations of postModifyNamespace when the operation fails"); // Validate that the postDeletNS hook is invoked preCount = observer.postHookCalls.get(); admin .modifyNamespace(NamespaceDescriptor.create(nsDesc).addConfiguration("foo", "bar").build()); postCount = observer.postHookCalls.get(); - assertEquals("Expected 1 invocation of postModifyNamespace", preCount + 1, postCount); + assertEquals(preCount + 1, postCount, "Expected 1 invocation of postModifyNamespace"); } @Test @@ -220,7 +215,7 @@ public void testPostCreateNamespace() throws IOException { NamespaceDescriptor nsDesc = NamespaceDescriptor.create(ns).build(); admin.createNamespace(nsDesc); int postCount = observer.postHookCalls.get(); - assertEquals("Expected 1 invocation of postModifyNamespace", preCount + 1, postCount); + assertEquals(preCount + 1, postCount, "Expected 1 invocation of postModifyNamespace"); // Then, validate that it's not called when the call fails preCount = observer.postHookCalls.get(); @@ -231,8 +226,8 @@ public void testPostCreateNamespace() throws IOException { // Pass } postCount = observer.postHookCalls.get(); - assertEquals("Expected no invocations of postModifyNamespace when the operation fails", - preCount, postCount); + assertEquals(preCount, postCount, + "Expected no invocations of postModifyNamespace when the operation fails"); } @Test @@ -251,7 +246,7 @@ public void testPostCreateTable() throws IOException { int preCount = observer.postHookCalls.get(); admin.createTable(td); int postCount = observer.postHookCalls.get(); - assertEquals("Expected 1 invocation of postCreateTable", preCount + 1, postCount); + assertEquals(preCount + 1, postCount, "Expected 1 invocation of postCreateTable"); // Then, validate that it's not called when the call fails preCount = observer.postHookCalls.get(); @@ -262,8 +257,8 @@ public void testPostCreateTable() throws IOException { // Pass } postCount = observer.postHookCalls.get(); - assertEquals("Expected no invocations of postCreateTable when the operation fails", preCount, - postCount); + assertEquals(preCount, postCount, + "Expected no invocations of postCreateTable when the operation fails"); } @Test @@ -285,7 +280,7 @@ public void testPostModifyTable() throws IOException { int preCount = observer.postHookCalls.get(); admin.modifyTable(td); int postCount = observer.postHookCalls.get(); - assertEquals("Expected 1 invocation of postModifyTable", preCount + 1, postCount); + assertEquals(preCount + 1, postCount, "Expected 1 invocation of postModifyTable"); // Then, validate that it's not called when the call fails preCount = observer.postHookCalls.get(); @@ -297,8 +292,8 @@ public void testPostModifyTable() throws IOException { // Pass } postCount = observer.postHookCalls.get(); - assertEquals("Expected no invocations of postModifyTable when the operation fails", preCount, - postCount); + assertEquals(preCount, postCount, + "Expected no invocations of postModifyTable when the operation fails"); } @Test @@ -320,7 +315,7 @@ public void testPostDisableTable() throws IOException { int preCount = observer.postHookCalls.get(); admin.disableTable(td.getTableName()); int postCount = observer.postHookCalls.get(); - assertEquals("Expected 1 invocation of postDisableTable", preCount + 1, postCount); + assertEquals(preCount + 1, postCount, "Expected 1 invocation of postDisableTable"); // Then, validate that it's not called when the call fails preCount = observer.postHookCalls.get(); @@ -331,8 +326,8 @@ public void testPostDisableTable() throws IOException { // Pass } postCount = observer.postHookCalls.get(); - assertEquals("Expected no invocations of postDisableTable when the operation fails", preCount, - postCount); + assertEquals(preCount, postCount, + "Expected no invocations of postDisableTable when the operation fails"); } @Test @@ -355,7 +350,7 @@ public void testPostDeleteTable() throws IOException { int preCount = observer.postHookCalls.get(); admin.deleteTable(td.getTableName()); int postCount = observer.postHookCalls.get(); - assertEquals("Expected 1 invocation of postDeleteTable", preCount + 1, postCount); + assertEquals(preCount + 1, postCount, "Expected 1 invocation of postDeleteTable"); // Then, validate that it's not called when the call fails preCount = observer.postHookCalls.get(); @@ -366,7 +361,7 @@ public void testPostDeleteTable() throws IOException { // Pass } postCount = observer.postHookCalls.get(); - assertEquals("Expected no invocations of postDeleteTable when the operation fails", preCount, - postCount); + assertEquals(preCount, postCount, + "Expected no invocations of postDeleteTable when the operation fails"); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureEvents.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureEvents.java index 39bce246e3a4..90086a510d53 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureEvents.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureEvents.java @@ -17,12 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; @@ -39,37 +38,36 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.CommonFSUtils; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestMasterProcedureEvents { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMasterProcedureEvents.class); - private static final Logger LOG = LoggerFactory.getLogger(TestCreateTableProcedure.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } private static void setupConf(Configuration conf) throws IOException { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); conf.setBoolean(WALProcedureStore.USE_HSYNC_CONF_KEY, false); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { Configuration conf = UTIL.getConfiguration(); setupConf(UTIL.getConfiguration()); @@ -79,7 +77,7 @@ public static void setupCluster() throws Exception { UTIL.waitUntilNoRegionsInTransition(); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); @@ -88,7 +86,7 @@ public static void cleanupTest() throws Exception { } } - @After + @AfterEach public void tearDown() throws Exception { for (TableDescriptor htd : UTIL.getAdmin().listTableDescriptors()) { LOG.info("Tear down, remove table=" + htd.getTableName()); @@ -98,7 +96,7 @@ public void tearDown() throws Exception { @Test public void testMasterInitializedEvent() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); HMaster master = UTIL.getMiniHBaseCluster().getMaster(); ProcedureExecutor procExec = master.getMasterProcedureExecutor(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureScheduler.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureScheduler.java index 7dc09837c478..e0edabde4b32 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureScheduler.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureScheduler.java @@ -17,11 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.lang.reflect.Field; @@ -30,7 +30,6 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; @@ -46,42 +45,40 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestMasterProcedureScheduler { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMasterProcedureScheduler.class); - private static final Logger LOG = LoggerFactory.getLogger(TestMasterProcedureScheduler.class); private MasterProcedureScheduler queue; private Map> procedures; + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - @Before + @BeforeEach public void setUp() throws IOException { procedures = new HashMap<>(); queue = new MasterProcedureScheduler(procedures::get); queue.start(); } - @After + @AfterEach public void tearDown() throws IOException { - assertEquals("proc-queue expected to be empty", 0, queue.size()); + assertEquals(0, queue.size(), "proc-queue expected to be empty"); queue.stop(); queue.clear(); } @@ -135,7 +132,7 @@ public void testSimpleTableOpsQueues() throws Exception { */ @Test public void testCreateDeleteTableOperationsWithWriteLock() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final TestTableProcedure dummyProc = new TestTableProcedure(100, tableName, TableProcedureInterface.TableOperationType.DELETE); @@ -166,7 +163,7 @@ public void testCreateDeleteTableOperationsWithWriteLock() throws Exception { */ @Test public void testCreateDeleteTableOperationsWithReadLock() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final int nitems = 2; final TestTableProcedure dummyProc = @@ -210,7 +207,7 @@ public void testCreateDeleteTableOperationsWithReadLock() throws Exception { */ @Test public void testVerifyRwLocks() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); queue.addBack( new TestTableProcedure(1, tableName, TableProcedureInterface.TableOperationType.EDIT)); queue.addBack( @@ -271,15 +268,15 @@ public void testVerifyRwLocks() throws Exception { // remove table queue assertEquals(0, queue.size()); - assertTrue("queue should be deleted", queue.markTableAsDeleted(tableName, wrProc)); + assertTrue(queue.markTableAsDeleted(tableName, wrProc), "queue should be deleted"); } @Test public void testVerifyNamespaceRwLocks() throws Exception { String nsName1 = "ns1"; String nsName2 = "ns2"; - TableName tableName1 = TableName.valueOf(nsName1, name.getMethodName()); - TableName tableName2 = TableName.valueOf(nsName2, name.getMethodName()); + TableName tableName1 = TableName.valueOf(nsName1, testMethodName); + TableName tableName2 = TableName.valueOf(nsName2, testMethodName); queue.addBack( new TestNamespaceProcedure(1, nsName1, TableProcedureInterface.TableOperationType.EDIT)); queue.addBack( @@ -329,7 +326,7 @@ public void testVerifyNamespaceRwLocks() throws Exception { @Test public void testVerifyNamespaceXLock() throws Exception { String nsName = "ns1"; - TableName tableName = TableName.valueOf(nsName, name.getMethodName()); + TableName tableName = TableName.valueOf(nsName, testMethodName); queue.addBack( new TestNamespaceProcedure(1, nsName, TableProcedureInterface.TableOperationType.CREATE)); queue.addBack( @@ -354,7 +351,7 @@ public void testVerifyNamespaceXLock() throws Exception { @Test public void testXLockWaitingForExecutingSharedLockToRelease() { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final RegionInfo regionA = RegionInfoBuilder.newBuilder(tableName) .setStartKey(Bytes.toBytes("a")).setEndKey(Bytes.toBytes("b")).build(); @@ -400,7 +397,7 @@ public void testXLockWaitingForExecutingSharedLockToRelease() { @Test public void testVerifyRegionLocks() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final RegionInfo regionA = RegionInfoBuilder.newBuilder(tableName) .setStartKey(Bytes.toBytes("a")).setEndKey(Bytes.toBytes("b")).build(); final RegionInfo regionB = RegionInfoBuilder.newBuilder(tableName) @@ -476,7 +473,7 @@ public void testVerifyRegionLocks() throws Exception { @Test public void testVerifySubProcRegionLocks() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final RegionInfo regionA = RegionInfoBuilder.newBuilder(tableName) .setStartKey(Bytes.toBytes("a")).setEndKey(Bytes.toBytes("b")).build(); final RegionInfo regionB = RegionInfoBuilder.newBuilder(tableName) @@ -538,7 +535,7 @@ public void testVerifySubProcRegionLocks() throws Exception { @Test public void testInheritedRegionXLock() { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final RegionInfo region = RegionInfoBuilder.newBuilder(tableName) .setStartKey(Bytes.toBytes("a")).setEndKey(Bytes.toBytes("b")).build(); @@ -582,7 +579,7 @@ public void testInheritedRegionXLock() { @Test public void testSuspendedProcedure() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); queue.addBack( new TestTableProcedure(1, tableName, TableProcedureInterface.TableOperationType.READ)); @@ -620,7 +617,7 @@ private static RegionInfo[] generateRegionInfo(final TableName tableName) { @Test public void testParentXLockAndChildrenSharedLock() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final RegionInfo[] regions = generateRegionInfo(tableName); final TestRegionProcedure[] childProcs = new TestRegionProcedure[regions.length]; for (int i = 0; i < regions.length; ++i) { @@ -634,7 +631,7 @@ public void testParentXLockAndChildrenSharedLock() throws Exception { @Test public void testRootXLockAndChildrenSharedLock() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final RegionInfo[] regions = generateRegionInfo(tableName); final TestRegionProcedure[] childProcs = new TestRegionProcedure[regions.length]; for (int i = 0; i < regions.length; ++i) { @@ -694,7 +691,7 @@ private void testInheritedXLockAndChildrenSharedLock(final TableName tableName, @Test public void testParentXLockAndChildrenXLock() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testInheritedXLockAndChildrenXLock(tableName, new TestTableProcedure(1, tableName, TableProcedureInterface.TableOperationType.EDIT), new TestTableProcedure(1, 2, tableName, TableProcedureInterface.TableOperationType.EDIT)); @@ -702,7 +699,7 @@ public void testParentXLockAndChildrenXLock() throws Exception { @Test public void testRootXLockAndChildrenXLock() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); // simulate 3 procedures: 1 (root), (2) child of root, (3) child of proc-2 testInheritedXLockAndChildrenXLock(tableName, new TestTableProcedure(1, tableName, TableProcedureInterface.TableOperationType.EDIT), @@ -739,7 +736,7 @@ private void testInheritedXLockAndChildrenXLock(final TableName tableName, @Test public void testYieldWithXLockHeld() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); queue.addBack( new TestTableProcedure(1, tableName, TableProcedureInterface.TableOperationType.EDIT)); @@ -770,7 +767,7 @@ public void testYieldWithXLockHeld() throws Exception { @Test public void testYieldWithSharedLockHeld() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); queue.addBack( new TestTableProcedure(1, tableName, TableProcedureInterface.TableOperationType.READ)); @@ -1196,7 +1193,7 @@ public void testListLocksWaiting() throws Exception { @Test public void testAcquireSharedLockWhileParentHoldingExclusiveLock() { - TableName tableName = TableName.valueOf(name.getMethodName()); + TableName tableName = TableName.valueOf(testMethodName); RegionInfo regionInfo = RegionInfoBuilder.newBuilder(tableName).build(); TestTableProcedure parentProc = new TestTableProcedure(1, tableName, TableOperationType.EDIT); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureSchedulerConcurrency.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureSchedulerConcurrency.java index 5729753b84b2..e685f4138fa8 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureSchedulerConcurrency.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestMasterProcedureSchedulerConcurrency.java @@ -17,14 +17,13 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.ArrayList; import java.util.HashSet; import java.util.concurrent.atomic.AtomicInteger; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.master.procedure.PeerProcedureInterface.PeerOperationType; import org.apache.hadoop.hbase.master.procedure.TestMasterProcedureScheduler.TestPeerProcedure; @@ -32,35 +31,31 @@ import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestMasterProcedureSchedulerConcurrency { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMasterProcedureSchedulerConcurrency.class); - private static final Logger LOG = LoggerFactory.getLogger(TestMasterProcedureSchedulerConcurrency.class); private MasterProcedureScheduler queue; - @Before + @BeforeEach public void setUp() throws IOException { queue = new MasterProcedureScheduler(pid -> null); queue.start(); } - @After + @AfterEach public void tearDown() throws IOException { - assertEquals("proc-queue expected to be empty", 0, queue.size()); + assertEquals(0, queue.size(), "proc-queue expected to be empty"); queue.stop(); queue.clear(); } @@ -102,22 +97,22 @@ public void run() { String peerId = proc.getPeerId(); synchronized (concurrentPeers) { - assertTrue("unexpected concurrency on " + peerId, concurrentPeers.add(peerId)); + assertTrue(concurrentPeers.add(peerId), "unexpected concurrency on " + peerId); } assertTrue(opsCount.decrementAndGet() >= 0); try { long procId = proc.getProcId(); int concurrent = concurrentCount.incrementAndGet(); - assertTrue("inc-concurrent=" + concurrent + " 1 <= concurrent <= " + NUM_PEERS, - concurrent >= 1 && concurrent <= NUM_PEERS); + assertTrue(concurrent >= 1 && concurrent <= NUM_PEERS, + "inc-concurrent=" + concurrent + " 1 <= concurrent <= " + NUM_PEERS); LOG.debug( "[S] peerId=" + peerId + " procId=" + procId + " concurrent=" + concurrent); Thread.sleep(2000); concurrent = concurrentCount.decrementAndGet(); LOG.debug( "[E] peerId=" + peerId + " procId=" + procId + " concurrent=" + concurrent); - assertTrue("dec-concurrent=" + concurrent, concurrent < NUM_PEERS); + assertTrue(concurrent < NUM_PEERS, "dec-concurrent=" + concurrent); } finally { synchronized (concurrentPeers) { assertTrue(concurrentPeers.remove(peerId)); @@ -141,7 +136,7 @@ public void run() { for (int i = 0; i < threads.length; ++i) { threads[i].join(); } - assertTrue(failures.toString(), failures.isEmpty()); + assertTrue(failures.isEmpty(), failures.toString()); assertEquals(0, opsCount.get()); assertEquals(0, queue.size()); } @@ -188,21 +183,21 @@ public void run() { TableName tableId = procSet.getTableName(proc); synchronized (concurrentTables) { - assertTrue("unexpected concurrency on " + tableId, concurrentTables.add(tableId)); + assertTrue(concurrentTables.add(tableId), "unexpected concurrency on " + tableId); } assertTrue(opsCount.decrementAndGet() >= 0); try { long procId = proc.getProcId(); int concurrent = concurrentCount.incrementAndGet(); - assertTrue("inc-concurrent=" + concurrent + " 1 <= concurrent <= " + NUM_TABLES, - concurrent >= 1 && concurrent <= NUM_TABLES); + assertTrue(concurrent >= 1 && concurrent <= NUM_TABLES, + "inc-concurrent=" + concurrent + " 1 <= concurrent <= " + NUM_TABLES); LOG.debug( "[S] tableId=" + tableId + " procId=" + procId + " concurrent=" + concurrent); Thread.sleep(2000); concurrent = concurrentCount.decrementAndGet(); LOG.debug( "[E] tableId=" + tableId + " procId=" + procId + " concurrent=" + concurrent); - assertTrue("dec-concurrent=" + concurrent, concurrent < NUM_TABLES); + assertTrue(concurrent < NUM_TABLES, "dec-concurrent=" + concurrent); } finally { synchronized (concurrentTables) { assertTrue(concurrentTables.remove(tableId)); @@ -225,7 +220,7 @@ public void run() { for (int i = 0; i < threads.length; ++i) { threads[i].join(); } - assertTrue(failures.toString(), failures.isEmpty()); + assertTrue(failures.isEmpty(), failures.toString()); assertEquals(0, opsCount.get()); assertEquals(0, queue.size()); @@ -233,8 +228,8 @@ public void run() { final TableName table = TableName.valueOf(String.format("testtb-%04d", i)); final TestTableProcedure dummyProc = new TestTableProcedure(100, table, TableProcedureInterface.TableOperationType.DELETE); - assertTrue("queue should be deleted, table=" + table, - queue.markTableAsDeleted(table, dummyProc)); + assertTrue(queue.markTableAsDeleted(table, dummyProc), + "queue should be deleted, table=" + table); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java index ecdc01736af5..f1cac5a317df 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java @@ -17,12 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.NamespaceNotFoundException; @@ -33,23 +32,19 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestModifyNamespaceProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestModifyNamespaceProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestModifyNamespaceProcedure.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -58,13 +53,13 @@ private static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); @@ -73,12 +68,12 @@ public static void cleanupTest() throws Exception { } } - @Before + @BeforeEach public void setup() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); } - @After + @AfterEach public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); for (TableDescriptor htd : UTIL.getAdmin().listTableDescriptors()) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java index 26b190f798b4..69284a95171c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java @@ -17,14 +17,15 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import org.apache.hadoop.hbase.ConcurrentTableModificationException; import org.apache.hadoop.hbase.DoNotRetryIOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.InvalidFamilyOperationException; import org.apache.hadoop.hbase.TableName; @@ -48,22 +49,32 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.NonceKey; import org.apache.hadoop.hbase.util.TableDescriptorChecker; -import org.junit.Assert; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; - -@Category({ MasterTests.class, LargeTests.class }) +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; + +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestModifyTableProcedure extends TestTableDDLProcedureBase { + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } + + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestModifyTableProcedure.class); + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } private static final String column_Family1 = "cf1"; private static final String column_Family2 = "cf2"; @@ -71,7 +82,7 @@ public class TestModifyTableProcedure extends TestTableDDLProcedureBase { @Test public void testModifyTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "cf"); @@ -109,7 +120,7 @@ public void testModifyTable() throws Exception { @Test public void testModifyTableAddCF() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "cf1"); @@ -152,7 +163,7 @@ public void testModifyTableAddCF() throws Exception { @Test public void testModifyTableDeleteCF() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String cf1 = "cf1"; final String cf2 = "cf2"; final String cf3 = "cf3"; @@ -199,15 +210,15 @@ public void testModifyTableDeleteCF() throws Exception { final Procedure result = procExec.getResult(procId3); assertEquals(true, result.isFailed()); Throwable cause = ProcedureTestingUtility.getExceptionCause(result); - assertTrue("expected DoNotRetryIOException, got " + cause, - cause instanceof DoNotRetryIOException); + assertTrue(cause instanceof DoNotRetryIOException, + "expected DoNotRetryIOException, got " + cause); assertEquals(1, currentHtd.getColumnFamilyNames().size()); assertTrue(currentHtd.hasColumnFamily(Bytes.toBytes(cf1))); } @Test public void testRecoveryAndDoubleExecutionOffline() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String cf2 = "cf2"; final String cf3 = "cf3"; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -246,7 +257,7 @@ public void testRecoveryAndDoubleExecutionOffline() throws Exception { @Test public void testRecoveryAndDoubleExecutionOnline() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String cf2 = "cf2"; final String cf3 = "cf3"; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -288,7 +299,7 @@ public void testRecoveryAndDoubleExecutionOnline() throws Exception { @Test public void testColumnFamilyAdditionTwiceWithNonce() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String cf2 = "cf2"; final String cf3 = "cf3"; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -333,7 +344,7 @@ public boolean execute(int step) throws IOException { UTIL.getHBaseCluster().getMaster().addColumn(tableName, ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(cf2)).build(), nonceGroup, nonceGenerator.newNonce()); - Assert.fail(); + fail(); } catch (InvalidFamilyOperationException e) { } @@ -351,7 +362,7 @@ public boolean execute(int step) throws IOException { @Test public void testRollbackAndDoubleExecutionOnline() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String familyName = "cf2"; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -380,7 +391,7 @@ public void testRollbackAndDoubleExecutionOnline() throws Exception { @Test public void testRollbackAndDoubleExecutionOffline() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String familyName = "cf2"; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -413,7 +424,7 @@ public void testRollbackAndDoubleExecutionOffline() throws Exception { @Test public void testConcurrentAddColumnFamily() throws IOException, InterruptedException { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); UTIL.createTable(tableName, column_Family1); class ConcurrentAddColumnFamily extends Thread { @@ -451,13 +462,14 @@ public void run() { t1.join(); t2.join(); int noOfColumnFamilies = UTIL.getAdmin().getDescriptor(tableName).getColumnFamilies().length; - assertTrue("Expected ConcurrentTableModificationException.", - ((t1.exception || t2.exception) && noOfColumnFamilies == 2) || noOfColumnFamilies == 3); + assertTrue( + ((t1.exception || t2.exception) && noOfColumnFamilies == 2) || noOfColumnFamilies == 3, + "Expected ConcurrentTableModificationException."); } @Test public void testConcurrentDeleteColumnFamily() throws IOException, InterruptedException { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(tableName); ColumnFamilyDescriptor columnFamilyDescriptor = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(column_Family1)).build(); @@ -500,13 +512,14 @@ public void run() { t1.join(); t2.join(); int noOfColumnFamilies = UTIL.getAdmin().getDescriptor(tableName).getColumnFamilies().length; - assertTrue("Expected ConcurrentTableModificationException.", - ((t1.exception || t2.exception) && noOfColumnFamilies == 2) || noOfColumnFamilies == 1); + assertTrue( + ((t1.exception || t2.exception) && noOfColumnFamilies == 2) || noOfColumnFamilies == 1, + "Expected ConcurrentTableModificationException."); } @Test public void testConcurrentModifyColumnFamily() throws IOException, InterruptedException { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); UTIL.createTable(tableName, column_Family1); class ConcurrentModifyColumnFamily extends Thread { @@ -546,13 +559,13 @@ public void run() { int maxVersions = UTIL.getAdmin().getDescriptor(tableName) .getColumnFamily(column_Family1.getBytes()).getMaxVersions(); - assertTrue("Expected ConcurrentTableModificationException.", (t1.exception && maxVersions == 5) - || (t2.exception && maxVersions == 6) || !(t1.exception && t2.exception)); + assertTrue((t1.exception && maxVersions == 5) || (t2.exception && maxVersions == 6) + || !(t1.exception && t2.exception), "Expected ConcurrentTableModificationException."); } @Test public void testConcurrentModifyTable() throws IOException, InterruptedException { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); UTIL.createTable(tableName, column_Family1); class ConcurrentModifyTable extends Thread { @@ -588,13 +601,13 @@ public void run() { t1.join(); t2.join(); - assertFalse("Expected ConcurrentTableModificationException.", (t1.exception || t2.exception)); + assertFalse((t1.exception || t2.exception), "Expected ConcurrentTableModificationException."); } @Test public void testModifyWillNotReopenRegions() throws IOException { final boolean reopenRegions = false; - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "cf"); @@ -610,7 +623,7 @@ public void testModifyWillNotReopenRegions() throws IOException { assertEquals("test.hbase.conf.value", currentHtd.getValue("test.hbase.conf")); // Regions should not aware of any changes. for (HRegion r : UTIL.getHBaseCluster().getRegions(tableName)) { - Assert.assertNull(r.getTableDescriptor().getValue("test.hbase.conf")); + assertNull(r.getTableDescriptor().getValue("test.hbase.conf")); } // Force regions to reopen for (HRegion r : UTIL.getHBaseCluster().getRegions(tableName)) { @@ -628,8 +641,7 @@ public void testModifyWillNotReopenRegions() throws IOException { try { ProcedureTestingUtility.submitAndWait(procExec, new ModifyTableProcedure( procExec.getEnvironment(), modifiedDescriptor, null, htd, false, reopenRegions)); - Assert.fail( - "An exception should have been thrown while modifying region replication properties."); + fail("An exception should have been thrown while modifying region replication properties."); } catch (HBaseIOException e) { assertTrue(e.getMessage().contains("Can not modify")); } @@ -645,12 +657,12 @@ public void testModifyWillNotReopenRegions() throws IOException { try { ProcedureTestingUtility.submitAndWait(procExec, new ModifyTableProcedure( procExec.getEnvironment(), modifiedDescriptor, null, htd, false, reopenRegions)); - Assert.fail("Should have thrown an exception while modifying CF!"); + fail("Should have thrown an exception while modifying CF!"); } catch (HBaseIOException e) { assertTrue(e.getMessage().contains("Cannot add or remove column families")); } currentHtd = UTIL.getAdmin().getDescriptor(tableName); - Assert.assertNull(currentHtd.getColumnFamily("NewCF".getBytes())); + assertNull(currentHtd.getColumnFamily("NewCF".getBytes())); // Test 4: Modifying CF property is allowed htd = UTIL.getAdmin().getDescriptor(tableName); @@ -662,14 +674,14 @@ public void testModifyWillNotReopenRegions() throws IOException { ProcedureTestingUtility.submitAndWait(procExec, new ModifyTableProcedure( procExec.getEnvironment(), modifiedDescriptor, null, htd, false, reopenRegions)); for (HRegion r : UTIL.getHBaseCluster().getRegions(tableName)) { - Assert.assertEquals(Compression.Algorithm.NONE, + assertEquals(Compression.Algorithm.NONE, r.getTableDescriptor().getColumnFamily("cf".getBytes()).getCompressionType()); } for (HRegion r : UTIL.getHBaseCluster().getRegions(tableName)) { getMaster().getAssignmentManager().move(r.getRegionInfo()); } for (HRegion r : UTIL.getHBaseCluster().getRegions(tableName)) { - Assert.assertEquals(Compression.Algorithm.SNAPPY, + assertEquals(Compression.Algorithm.SNAPPY, r.getTableDescriptor().getColumnFamily("cf".getBytes()).getCompressionType()); } @@ -681,7 +693,7 @@ public void testModifyWillNotReopenRegions() throws IOException { try { ProcedureTestingUtility.submitAndWait(procExec, new ModifyTableProcedure( procExec.getEnvironment(), modifiedDescriptor, null, htd, false, reopenRegions)); - Assert.fail("Should have thrown an exception while modifying coprocessor!"); + fail("Should have thrown an exception while modifying coprocessor!"); } catch (HBaseIOException e) { assertTrue(e.getMessage().contains("Can not modify Coprocessor")); } @@ -694,7 +706,7 @@ public void testModifyWillNotReopenRegions() throws IOException { try { ProcedureTestingUtility.submitAndWait(procExec, new ModifyTableProcedure( procExec.getEnvironment(), modifiedDescriptor, null, htd, false, reopenRegions)); - Assert.fail("Should have thrown an exception while modifying coprocessor!"); + fail("Should have thrown an exception while modifying coprocessor!"); } catch (HBaseIOException e) { System.out.println(e.getMessage()); assertTrue(e.getMessage().contains("Can not modify REGION_REPLICATION")); @@ -710,7 +722,7 @@ public void testModifyTableWithCoprocessorAndColumnFamilyPropertyChange() throws // instead of actual descriptor content, which failed when HashMap iteration order varied. final boolean reopenRegions = false; - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "cf"); @@ -730,9 +742,9 @@ public void testModifyTableWithCoprocessorAndColumnFamilyPropertyChange() throws // Verify coprocessors were added TableDescriptor currentHtd = UTIL.getAdmin().getDescriptor(tableName); assertEquals(2, currentHtd.getCoprocessorDescriptors().size()); - assertTrue("First coprocessor should be present", - currentHtd.hasCoprocessor(SimpleRegionObserver.class.getName())); - assertTrue("Second coprocessor should be present", currentHtd.hasCoprocessor(cp2)); + assertTrue(currentHtd.hasCoprocessor(SimpleRegionObserver.class.getName()), + "First coprocessor should be present"); + assertTrue(currentHtd.hasCoprocessor(cp2), "Second coprocessor should be present"); // Step 2: Modify only the column family property (COMPRESSION) with REOPEN_REGIONS=false // This should SUCCEED because we're not actually modifying the coprocessor, @@ -751,18 +763,20 @@ public void testModifyTableWithCoprocessorAndColumnFamilyPropertyChange() throws // Verify the modification succeeded currentHtd = UTIL.getAdmin().getDescriptor(tableName); - assertEquals("Coprocessors should still be present", 2, - currentHtd.getCoprocessorDescriptors().size()); - assertTrue("First coprocessor should still be present", - currentHtd.hasCoprocessor(SimpleRegionObserver.class.getName())); - assertTrue("Second coprocessor should still be present", currentHtd.hasCoprocessor(cp2)); - assertEquals("Compression should be updated in table descriptor", Compression.Algorithm.SNAPPY, - currentHtd.getColumnFamily("cf".getBytes()).getCompressionType()); + assertEquals(2, currentHtd.getCoprocessorDescriptors().size(), + "Coprocessors should still be present"); + assertTrue(currentHtd.hasCoprocessor(SimpleRegionObserver.class.getName()), + "First coprocessor should still be present"); + assertTrue(currentHtd.hasCoprocessor(cp2), "Second coprocessor should still be present"); + assertEquals(Compression.Algorithm.SNAPPY, + currentHtd.getColumnFamily("cf".getBytes()).getCompressionType(), + "Compression should be updated in table descriptor"); // Verify regions haven't picked up the change yet (since reopenRegions=false) for (HRegion r : UTIL.getHBaseCluster().getRegions(tableName)) { - assertEquals("Regions should still have old compression", Compression.Algorithm.NONE, - r.getTableDescriptor().getColumnFamily("cf".getBytes()).getCompressionType()); + assertEquals(Compression.Algorithm.NONE, + r.getTableDescriptor().getColumnFamily("cf".getBytes()).getCompressionType(), + "Regions should still have old compression"); } // Force regions to reopen @@ -772,9 +786,9 @@ public void testModifyTableWithCoprocessorAndColumnFamilyPropertyChange() throws // After reopen, regions should have the new compression setting for (HRegion r : UTIL.getHBaseCluster().getRegions(tableName)) { - assertEquals("Regions should now have new compression after reopen", - Compression.Algorithm.SNAPPY, - r.getTableDescriptor().getColumnFamily("cf".getBytes()).getCompressionType()); + assertEquals(Compression.Algorithm.SNAPPY, + r.getTableDescriptor().getColumnFamily("cf".getBytes()).getCompressionType(), + "Regions should now have new compression after reopen"); } } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedureWithRecovery.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedureWithRecovery.java index 1eccfc82ecda..f1d26c7e0dad 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedureWithRecovery.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedureWithRecovery.java @@ -17,10 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; @@ -32,36 +31,42 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableState; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestModifyTableProcedureWithRecovery extends TestTableDDLProcedureBase { + private String testMethodName; - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestModifyTableProcedureWithRecovery.class); - - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { // Enable recovery snapshots + TestTableDDLProcedureBase.setupConf(UTIL.getConfiguration()); UTIL.getConfiguration().setBoolean(HConstants.SNAPSHOT_BEFORE_DESTRUCTIVE_ACTION_ENABLED_KEY, true); - TestTableDDLProcedureBase.setupCluster(); + UTIL.startMiniCluster(1); + } + + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); } @Test public void testRecoverySnapshotRollback() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String cf1 = "cf1"; final String cf2 = "cf2"; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -86,7 +91,7 @@ public void testRecoverySnapshotRollback() throws Exception { // Wait for procedure to complete (should fail) ProcedureTestingUtility.waitProcedure(procExec, procId); Procedure result = procExec.getResult(procId); - assertTrue("Procedure should have failed", result.isFailed()); + assertTrue(result.isFailed(), "Procedure should have failed"); // Verify no recovery snapshots remain after rollback boolean snapshotFound = false; @@ -96,13 +101,13 @@ public void testRecoverySnapshotRollback() throws Exception { break; } } - assertTrue("Recovery snapshot should have been cleaned up during rollback", !snapshotFound); + assertTrue(!snapshotFound, "Recovery snapshot should have been cleaned up during rollback"); } @Test public void testRecoverySnapshotAndRestore() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); - final TableName restoredTableName = TableName.valueOf(name.getMethodName() + "_restored"); + final TableName tableName = TableName.valueOf(testMethodName); + final TableName restoredTableName = TableName.valueOf(testMethodName + "_restored"); final String cf1 = "cf1"; final String cf2 = "cf2"; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -124,8 +129,8 @@ public void testRecoverySnapshotAndRestore() throws Exception { // Verify table modification was successful TableDescriptor currentHtd = UTIL.getAdmin().getDescriptor(tableName); - assertEquals("Should have one column family", 1, currentHtd.getColumnFamilyNames().size()); - assertTrue("Should only have cf1", currentHtd.hasColumnFamily(cf1.getBytes())); + assertEquals(1, currentHtd.getColumnFamilyNames().size(), "Should have one column family"); + assertTrue(currentHtd.hasColumnFamily(cf1.getBytes()), "Should only have cf1"); // Find the recovery snapshot String recoverySnapshotName = null; @@ -135,7 +140,7 @@ public void testRecoverySnapshotAndRestore() throws Exception { break; } } - assertTrue("Recovery snapshot should exist", recoverySnapshotName != null); + assertTrue(recoverySnapshotName != null, "Recovery snapshot should exist"); // Restore from snapshot by cloning to a new table UTIL.getAdmin().cloneSnapshot(recoverySnapshotName, restoredTableName); @@ -143,9 +148,9 @@ public void testRecoverySnapshotAndRestore() throws Exception { // Verify restored table has original structure with both column families TableDescriptor restoredHtd = UTIL.getAdmin().getDescriptor(restoredTableName); - assertEquals("Should have two column families", 2, restoredHtd.getColumnFamilyNames().size()); - assertTrue("Should have cf1", restoredHtd.hasColumnFamily(cf1.getBytes())); - assertTrue("Should have cf2", restoredHtd.hasColumnFamily(cf2.getBytes())); + assertEquals(2, restoredHtd.getColumnFamilyNames().size(), "Should have two column families"); + assertTrue(restoredHtd.hasColumnFamily(cf1.getBytes()), "Should have cf1"); + assertTrue(restoredHtd.hasColumnFamily(cf2.getBytes()), "Should have cf2"); // Clean up the cloned table UTIL.getAdmin().disableTable(restoredTableName); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureAdmin.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureAdmin.java index 94539572a99c..622596c13721 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureAdmin.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureAdmin.java @@ -17,13 +17,12 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import java.util.concurrent.ThreadLocalRandom; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; @@ -33,28 +32,27 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestProcedureAdmin { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureAdmin.class); - private static final Logger LOG = LoggerFactory.getLogger(TestProcedureAdmin.class); - @Rule - public TestName name = new TestName(); + private String testMethodName; + + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -62,13 +60,13 @@ private static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); @@ -77,16 +75,16 @@ public static void cleanupTest() throws Exception { } } - @Before + @BeforeEach public void setup() throws Exception { final ProcedureExecutor procExec = getMasterProcedureExecutor(); ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); - assertTrue("expected executor to be running", procExec.isRunning()); + assertTrue(procExec.isRunning(), "expected executor to be running"); } - @After + @AfterEach public void tearDown() throws Exception { - assertTrue("expected executor to be running", getMasterProcedureExecutor().isRunning()); + assertTrue(getMasterProcedureExecutor().isRunning(), "expected executor to be running"); ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); for (TableDescriptor htd : UTIL.getAdmin().listTableDescriptors()) { LOG.info("Tear down, remove table=" + htd.getTableName()); @@ -96,7 +94,7 @@ public void tearDown() throws Exception { @Test public void testAbortProcedureSuccess() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f"); @@ -120,7 +118,7 @@ public void testAbortProcedureSuccess() throws Exception { @Test public void testAbortProcedureFailure() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); RegionInfo[] regions = @@ -152,7 +150,7 @@ public void testAbortProcedureFailure() throws Exception { @Test public void testAbortProcedureInterruptedNotAllowed() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f"); @@ -197,7 +195,7 @@ public void testAbortNonExistProcedure() throws Exception { @Test public void testGetProcedure() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f"); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java index d2f04c674c97..a796695c9ba8 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java @@ -25,7 +25,6 @@ import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import org.apache.hadoop.hbase.Cell; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.Waiter.ExplainingPredicate; @@ -50,11 +49,10 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.JVMClusterUtil.RegionServerThread; import org.apache.hadoop.hbase.wal.WALEdit; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; @@ -67,13 +65,10 @@ * adding procedure worker now, but it could still be used to make sure that we could make progress * when meta is gone and we have a lot of pending TRSPs. */ -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestProcedurePriority { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedurePriority.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static String TABLE_NAME_PREFIX = "TestProcedurePriority-"; @@ -112,7 +107,7 @@ public void prePut(ObserverContext c, Pu } } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.getConfiguration().setLong(ProcedureExecutor.WORKER_KEEP_ALIVE_TIME_CONF_KEY, 5000); UTIL.getConfiguration().setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 4); @@ -139,7 +134,7 @@ public static void setUp() throws Exception { UTIL.getAdmin().balancerSwitch(false, true); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureTracing.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureTracing.java index f81e1223dfb5..68b6214670a7 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureTracing.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureTracing.java @@ -31,16 +31,16 @@ import static org.hamcrest.Matchers.hasItem; import io.opentelemetry.api.trace.StatusCode; +import io.opentelemetry.sdk.testing.junit5.OpenTelemetryExtension; import io.opentelemetry.sdk.trace.data.SpanData; import java.util.List; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; -import org.apache.hadoop.hbase.ConnectionRule; -import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.ConnectionExtension; import org.apache.hadoop.hbase.HRegionLocation; import org.apache.hadoop.hbase.MatcherPredicate; -import org.apache.hadoop.hbase.MiniClusterRule; +import org.apache.hadoop.hbase.MiniClusterExtension; import org.apache.hadoop.hbase.StartTestingClusterOption; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.Waiter; @@ -51,58 +51,56 @@ import org.apache.hadoop.hbase.client.trace.StringTraceRenderer; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.apache.hadoop.hbase.trace.OpenTelemetryClassRule; -import org.apache.hadoop.hbase.trace.OpenTelemetryTestRule; import org.apache.hadoop.hbase.trace.TraceUtil; import org.apache.hadoop.hbase.util.Bytes; import org.hamcrest.Matcher; import org.hamcrest.Matchers; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.RuleChain; -import org.junit.rules.TestName; -import org.junit.rules.TestRule; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; +import org.junit.jupiter.api.extension.RegisterExtension; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Test of master ProcedureV2 tracing. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestProcedureTracing { private static final Logger LOG = LoggerFactory.getLogger(TestProcedureTracing.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureTracing.class); + @RegisterExtension + @Order(1) + static final OpenTelemetryExtension otelExtension = OpenTelemetryExtension.create(); - private static final OpenTelemetryClassRule otelClassRule = OpenTelemetryClassRule.create(); - private static final MiniClusterRule miniClusterRule = MiniClusterRule.newBuilder() + @RegisterExtension + @Order(2) + static final MiniClusterExtension miniClusterExtension = MiniClusterExtension.newBuilder() .setMiniClusterOption(StartTestingClusterOption.builder().numWorkers(3).build()).build(); - protected static final ConnectionRule connectionRule = - ConnectionRule.createAsyncConnectionRule(miniClusterRule::createAsyncConnection); - @ClassRule - public static final TestRule classRule = - RuleChain.outerRule(otelClassRule).around(miniClusterRule).around(connectionRule); + @RegisterExtension + @Order(3) + static final ConnectionExtension connectionExtension = + ConnectionExtension.createAsyncConnectionExtension(miniClusterExtension::createAsyncConnection); + private String testMethodName; - @Rule - public final OpenTelemetryTestRule otelTestRule = new OpenTelemetryTestRule(otelClassRule); - - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } @Test public void testCreateOpenDeleteTableSpans() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); - final AsyncConnection conn = connectionRule.getAsyncConnection(); + final TableName tableName = TableName.valueOf(testMethodName); + final AsyncConnection conn = connectionExtension.getAsyncConnection(); final AsyncAdmin admin = conn.getAdmin(); final AtomicReference> tableRegionsRef = new AtomicReference<>(); TraceUtil.trace(() -> { - try (final Table ignored = miniClusterRule.getTestingUtility() + try (final Table ignored = miniClusterExtension.getTestingUtility() .createMultiRegionTable(tableName, Bytes.toBytes("fam"), 5)) { final List tableRegions = conn.getRegionLocator(tableName).getAllRegionLocations() .get().stream().map(HRegionLocation::getRegion).map(RegionInfo::getEncodedName) @@ -115,19 +113,19 @@ public void testCreateOpenDeleteTableSpans() throws Exception { } admin.deleteTable(tableName).get(); } - }, name.getMethodName()); + }, testMethodName); - final Matcher testSpanMatcher = allOf(hasName(name.getMethodName()), hasEnded()); + final Matcher testSpanMatcher = allOf(hasName(testMethodName), hasEnded()); Waiter.waitFor(conn.getConfiguration(), TimeUnit.MINUTES.toMillis(3), - new MatcherPredicate<>(otelClassRule::getSpans, hasItem(testSpanMatcher))); - final List spans = otelClassRule.getSpans(); + new MatcherPredicate<>(otelExtension::getSpans, hasItem(testSpanMatcher))); + final List spans = otelExtension.getSpans(); final StringTraceRenderer renderer = new StringTraceRenderer(spans); renderer.render(LOG::debug); // Expect to find a span for a CreateTableProcedure for the test table final Matcher createTableProcedureSpanMatcher = allOf( - hasName(allOf(containsString("CreateTableProcedure"), - containsString("table=" + name.getMethodName()))), + hasName( + allOf(containsString("CreateTableProcedure"), containsString("table=" + testMethodName))), hasEnded(), hasStatusWithCode(StatusCode.OK), hasAttributes(allOf(containsEntry(longKey("procId"), any(Long.class)), containsEntry(longKey("parentProcId"), any(Long.class))))); @@ -137,7 +135,7 @@ public void testCreateOpenDeleteTableSpans() throws Exception { // Expect to find a span for a TransitRegionStateProcedure for the test table final Matcher transitRegionStateProcedureSpanMatcher = allOf( hasName(allOf(containsString("TransitRegionStateProcedure"), - containsString("table=" + name.getMethodName()))), + containsString("table=" + testMethodName))), hasEnded(), hasStatusWithCode(StatusCode.OK), hasAttributes(allOf(containsEntry(longKey("procId"), any(Long.class)), containsEntry(longKey("parentProcId"), any(Long.class))))); @@ -166,8 +164,8 @@ public void testCreateOpenDeleteTableSpans() throws Exception { // Expect to find a span for a DisableTableProcedure for the test table final Matcher disableTableProcedureSpanMatcher = allOf( - hasName(allOf(containsString("DisableTableProcedure"), - containsString("table=" + name.getMethodName()))), + hasName( + allOf(containsString("DisableTableProcedure"), containsString("table=" + testMethodName))), hasEnded(), hasStatusWithCode(StatusCode.OK), hasAttributes(allOf(containsEntry(longKey("procId"), any(Long.class)), containsEntry(longKey("parentProcId"), any(Long.class))))); @@ -176,8 +174,8 @@ public void testCreateOpenDeleteTableSpans() throws Exception { // Expect to find a span for a DeleteTableProcedure for the test table final Matcher deleteTableProcedureSpanMatcher = allOf( - hasName(allOf(containsString("DeleteTableProcedure"), - containsString("table=" + name.getMethodName()))), + hasName( + allOf(containsString("DeleteTableProcedure"), containsString("table=" + testMethodName))), hasEnded(), hasStatusWithCode(StatusCode.OK), hasAttributes(allOf(containsEntry(longKey("procId"), any(Long.class)), containsEntry(longKey("parentProcId"), any(Long.class))))); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureWaitAndWake.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureWaitAndWake.java index 284052111ee5..f402be68b642 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureWaitAndWake.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedureWaitAndWake.java @@ -19,7 +19,6 @@ import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.master.replication.AbstractPeerNoLockProcedure; import org.apache.hadoop.hbase.master.replication.AbstractPeerProcedure; @@ -28,22 +27,18 @@ import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; /** * Testcase for HBASE-29380 */ -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestProcedureWaitAndWake { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestProcedureWaitAndWake.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); public static final class MyPeerProcedure extends AbstractPeerProcedure { @@ -143,13 +138,13 @@ protected Integer getInitialState() { } } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.getConfiguration().setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 8); UTIL.startMiniCluster(3); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRaceBetweenSCPAndDTP.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRaceBetweenSCPAndDTP.java index 075ae8b9506a..a395a0cdae1f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRaceBetweenSCPAndDTP.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRaceBetweenSCPAndDTP.java @@ -21,7 +21,6 @@ import java.util.concurrent.CountDownLatch; import java.util.concurrent.Future; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.ServerName; @@ -36,11 +35,10 @@ import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.zookeeper.KeeperException; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -57,13 +55,10 @@ * special case, thues we removed the special logic in SCP and also the UT for HBASE-22636 is not * valid any more, so we just removed the old one and introduce a new one with the same name here. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestRaceBetweenSCPAndDTP { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRaceBetweenSCPAndDTP.class); - private static final Logger LOG = LoggerFactory.getLogger(TestRaceBetweenSCPAndDTP.class); private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -96,7 +91,7 @@ public ReplicationPeerManager getReplicationPeerManager() { } } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.getConfiguration().setClass(HConstants.MASTER_IMPL, HMasterForTest.class, HMaster.class); UTIL.startMiniCluster(2); @@ -105,7 +100,7 @@ public static void setUp() throws Exception { UTIL.getAdmin().balancerSwitch(false, true); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRecoverySnapshotUtils.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRecoverySnapshotUtils.java index 57cfe57716b5..3f0eb70168d5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRecoverySnapshotUtils.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRecoverySnapshotUtils.java @@ -17,12 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; @@ -30,17 +29,13 @@ import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, SmallTests.class }) +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestRecoverySnapshotUtils { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRecoverySnapshotUtils.class); - @Test public void testRecoverySnapshotTtlNoDescriptor() { // Create a mock MasterProcedureEnv with a known site configuration TTL @@ -53,8 +48,8 @@ public void testRecoverySnapshotTtlNoDescriptor() { // Test with null table descriptor - should return site configuration long actualTtl = RecoverySnapshotUtils.getRecoverySnapshotTtl(env, null); - assertEquals("Should return site-level TTL when no table descriptor provided", siteLevelTtl, - actualTtl); + assertEquals(siteLevelTtl, actualTtl, + "Should return site-level TTL when no table descriptor provided"); } @Test @@ -75,8 +70,8 @@ public void testRecoverySnapshotTtlWithDescriptor() { // Test with table descriptor override - should return table-level TTL long actualTtl = RecoverySnapshotUtils.getRecoverySnapshotTtl(env, tableDescriptor); - assertEquals("Should return table-level TTL when table descriptor provides override", - tableLevelTtl, actualTtl); + assertEquals(tableLevelTtl, actualTtl, + "Should return table-level TTL when table descriptor provides override"); } @Test @@ -90,7 +85,7 @@ public void testRecoverySnapshotTtlUsesDefault() { // Test with null table descriptor - should return default TTL long actualTtl = RecoverySnapshotUtils.getRecoverySnapshotTtl(env, null); - assertEquals("Should return default TTL when no site configuration provided", - HConstants.DEFAULT_SNAPSHOT_BEFORE_DESTRUCTIVE_ACTION_TTL, actualTtl); + assertEquals(HConstants.DEFAULT_SNAPSHOT_BEFORE_DESTRUCTIVE_ACTION_TTL, actualTtl, + "Should return default TTL when no site configuration provided"); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReloadQuotasProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReloadQuotasProcedure.java index 91c2a972ced4..09516dc2558a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReloadQuotasProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReloadQuotasProcedure.java @@ -17,47 +17,44 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.Optional; import java.util.concurrent.Future; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.master.assignment.MockMasterServices; import org.apache.hadoop.hbase.procedure2.RemoteProcedureDispatcher; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestReloadQuotasProcedure { private static final Logger LOG = LoggerFactory.getLogger(TestReloadQuotasProcedure.class); + private String testMethodName; - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestReloadQuotasProcedure.class); - - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } private HBaseTestingUtil util; private MockMasterServices master; private TestServerRemoteProcedure.MockRSProcedureDispatcher rsDispatcher; - @Before + @BeforeEach public void setUp() throws Exception { util = new HBaseTestingUtil(); master = new MockMasterServices(util.getConfiguration()); @@ -65,7 +62,7 @@ public void setUp() throws Exception { master.start(2, rsDispatcher); } - @After + @AfterEach public void tearDown() throws Exception { master.stop("tearDown"); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsIntegration.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsIntegration.java index 8c7a1ec80286..0684166fae2a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsIntegration.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsIntegration.java @@ -17,8 +17,8 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import java.util.ArrayList; import java.util.HashMap; @@ -27,7 +27,6 @@ import java.util.Map; import java.util.Set; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; @@ -40,31 +39,27 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestReopenTableRegionsIntegration { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestReopenTableRegionsIntegration.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static final TableName TABLE_NAME = TableName.valueOf("testLazyUpdateReopen"); private static final byte[] CF = Bytes.toBytes("cf"); - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { Configuration conf = UTIL.getConfiguration(); conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } @@ -84,7 +79,7 @@ public void testLazyUpdateThenReopenUpdatesTableDescriptorHash() throws Exceptio try { // Step 2: Capture initial tableDescriptorHash from all regions List regions = UTIL.getHBaseCluster().getRegions(TABLE_NAME); - assertEquals("Expected 3 regions", 3, regions.size()); + assertEquals(3, regions.size(), "Expected 3 regions"); Map initialHashes = new HashMap<>(); @@ -98,7 +93,7 @@ public void testLazyUpdateThenReopenUpdatesTableDescriptorHash() throws Exceptio // Verify all regions have same hash Set uniqueHashes = new HashSet<>(initialHashes.values()); - assertEquals("All regions should have same hash", 1, uniqueHashes.size()); + assertEquals(1, uniqueHashes.size(), "All regions should have same hash"); String initialHash = uniqueHashes.iterator().next(); // Step 3: Perform lazy table descriptor update @@ -128,14 +123,14 @@ public void testLazyUpdateThenReopenUpdatesTableDescriptorHash() throws Exceptio try (MetricsRegionWrapperImpl wrapper = new MetricsRegionWrapperImpl(region)) { currentHash = wrapper.getTableDescriptorHash(); } - assertEquals("Hash should NOT change without region reopen", - initialHashes.get(region.getRegionInfo().getRegionName()), currentHash); + assertEquals(initialHashes.get(region.getRegionInfo().getRegionName()), currentHash, + "Hash should NOT change without region reopen"); } // Verify the table descriptor itself has changed TableDescriptor currentTd = UTIL.getAdmin().getDescriptor(TABLE_NAME); String newDescriptorHash = currentTd.getDescriptorHash(); - assertNotEquals("Table descriptor should have new hash", initialHash, newDescriptorHash); + assertNotEquals(initialHash, newDescriptorHash, "Table descriptor should have new hash"); // Step 5: Use new Admin API to reopen all regions UTIL.getAdmin().reopenTableRegions(TABLE_NAME); @@ -166,15 +161,15 @@ public void testLazyUpdateThenReopenUpdatesTableDescriptorHash() throws Exceptio // Step 6: Verify tableDescriptorHash HAS changed in all region metrics List reopenedRegions = UTIL.getHBaseCluster().getRegions(TABLE_NAME); - assertEquals("Should still have 3 regions", 3, reopenedRegions.size()); + assertEquals(3, reopenedRegions.size(), "Should still have 3 regions"); for (HRegion region : reopenedRegions) { String currentHash; try (MetricsRegionWrapperImpl wrapper = new MetricsRegionWrapperImpl(region)) { currentHash = wrapper.getTableDescriptorHash(); } - assertNotEquals("Hash SHOULD change after region reopen", initialHash, currentHash); - assertEquals("Hash should match current table descriptor", newDescriptorHash, currentHash); + assertNotEquals(initialHash, currentHash, "Hash SHOULD change after region reopen"); + assertEquals(newDescriptorHash, currentHash, "Hash should match current table descriptor"); } // Verify all regions show the same new hash @@ -184,7 +179,7 @@ public void testLazyUpdateThenReopenUpdatesTableDescriptorHash() throws Exceptio newHashes.add(wrapper.getTableDescriptorHash()); } } - assertEquals("All regions should have same new hash", 1, newHashes.size()); + assertEquals(1, newHashes.size(), "All regions should have same new hash"); } finally { UTIL.deleteTable(TABLE_NAME); @@ -208,7 +203,7 @@ public void testLazyUpdateThenReopenSpecificRegions() throws Exception { try { // Step 2: Capture initial hashes List regions = UTIL.getHBaseCluster().getRegions(tableName); - assertEquals("Expected 5 regions", 5, regions.size()); + assertEquals(5, regions.size(), "Expected 5 regions"); Map initialHashes = new HashMap<>(); @@ -287,8 +282,8 @@ public void testLazyUpdateThenReopenSpecificRegions() throws Exception { } } - assertEquals("Should have 2 regions with new hash", 2, newHashCount); - assertEquals("Should have 3 regions with old hash", 3, oldHashCount); + assertEquals(2, newHashCount, "Should have 2 regions with new hash"); + assertEquals(3, oldHashCount, "Should have 3 regions with old hash"); // Step 6: Reopen remaining regions List remainingRegions = new ArrayList<>(); @@ -325,7 +320,7 @@ public void testLazyUpdateThenReopenSpecificRegions() throws Exception { currentHash = wrapper.getTableDescriptorHash(); } - assertEquals("All regions should now have new hash", newDescriptorHash, currentHash); + assertEquals(newDescriptorHash, currentHash, "All regions should now have new hash"); } } finally { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBackoff.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBackoff.java index 6c8aecd69b81..ecc34390da30 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBackoff.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBackoff.java @@ -17,10 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; @@ -33,11 +32,10 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -47,13 +45,10 @@ * Confirm that we will do backoff when retrying on reopening table regions, to avoid consuming all * the CPUs. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestReopenTableRegionsProcedureBackoff { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestReopenTableRegionsProcedureBackoff.class); - private static final Logger LOG = LoggerFactory.getLogger(TestReopenTableRegionsProcedureBackoff.class); @@ -63,14 +58,14 @@ public class TestReopenTableRegionsProcedureBackoff { private static byte[] CF = Bytes.toBytes("cf"); - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, 1); UTIL.startMiniCluster(1); UTIL.createTable(TABLE_NAME, CF); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatchBackoff.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatchBackoff.java index 8ab3607454af..9580b14d4f62 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatchBackoff.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatchBackoff.java @@ -17,15 +17,14 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.time.Duration; import java.time.Instant; import java.util.List; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; @@ -34,23 +33,19 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; /** * Confirm that we will rate limit reopen batches when reopening all table regions. This can avoid * the pain associated with reopening too many regions at once. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestReopenTableRegionsProcedureBatchBackoff { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestReopenTableRegionsProcedureBatchBackoff.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static TableName TABLE_NAME = TableName.valueOf("BatchBackoff"); @@ -61,7 +56,7 @@ public class TestReopenTableRegionsProcedureBatchBackoff { private static byte[] CF = Bytes.toBytes("cf"); - @BeforeClass + @BeforeAll public static void setUp() throws Exception { Configuration conf = UTIL.getConfiguration(); conf.setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, 1); @@ -69,7 +64,7 @@ public static void setUp() throws Exception { UTIL.createMultiRegionTable(TABLE_NAME, CF, NUM_REGIONS); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatching.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatching.java index aa1edd4f2111..fcf73c8981bd 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatching.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureBatching.java @@ -20,15 +20,14 @@ import static org.apache.hadoop.hbase.master.procedure.ReopenTableRegionsProcedure.PROGRESSIVE_BATCH_BACKOFF_MILLIS_DEFAULT; import static org.apache.hadoop.hbase.master.procedure.ReopenTableRegionsProcedure.PROGRESSIVE_BATCH_BACKOFF_MILLIS_KEY; import static org.apache.hadoop.hbase.master.procedure.ReopenTableRegionsProcedure.PROGRESSIVE_BATCH_SIZE_MAX_KEY; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.List; import java.util.Set; import java.util.stream.Collectors; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; @@ -43,11 +42,10 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; @@ -55,13 +53,10 @@ * Confirm that we will batch region reopens when reopening all table regions. This can avoid the * pain associated with reopening too many regions at once. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestReopenTableRegionsProcedureBatching { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestReopenTableRegionsProcedureBatching.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static final int BACKOFF_MILLIS_PER_RS = 0; private static final int REOPEN_BATCH_SIZE_MAX = 1; @@ -70,7 +65,7 @@ public class TestReopenTableRegionsProcedureBatching { private static byte[] CF = Bytes.toBytes("cf"); - @BeforeClass + @BeforeAll public static void setUp() throws Exception { Configuration conf = UTIL.getConfiguration(); conf.setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, 1); @@ -78,7 +73,7 @@ public static void setUp() throws Exception { UTIL.createMultiRegionTable(TABLE_NAME, CF); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureInfiniteLoop.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureInfiniteLoop.java index e9fc64a5b1d3..dfbbd05322ad 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureInfiniteLoop.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureInfiniteLoop.java @@ -18,7 +18,6 @@ package org.apache.hadoop.hbase.master.procedure; import java.io.IOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; @@ -31,36 +30,32 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; /** * Testcase for HBASE-21330. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestReopenTableRegionsProcedureInfiniteLoop { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestReopenTableRegionsProcedureInfiniteLoop.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static TableName TABLE_NAME = TableName.valueOf("InfiniteLoop"); private static byte[] CF = Bytes.toBytes("cf"); - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, 1); UTIL.startMiniCluster(1); UTIL.createTable(TABLE_NAME, CF); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureSpecificRegions.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureSpecificRegions.java index a38ec490186d..33b336e837d1 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureSpecificRegions.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureSpecificRegions.java @@ -17,9 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.Collections; @@ -27,7 +27,6 @@ import java.util.Objects; import java.util.stream.Collectors; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.SingleProcessHBaseCluster; import org.apache.hadoop.hbase.TableName; @@ -43,32 +42,28 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestReopenTableRegionsProcedureSpecificRegions { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestReopenTableRegionsProcedureSpecificRegions.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static final byte[] CF = Bytes.toBytes("cf"); private static SingleProcessHBaseCluster singleProcessHBaseCluster; - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { Configuration conf = UTIL.getConfiguration(); conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); singleProcessHBaseCluster = UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); if (Objects.nonNull(singleProcessHBaseCluster)) { @@ -86,7 +81,7 @@ public void testInvalidRegionNamesThrowsException() throws Exception { try (Table ignored = UTIL.createTable(tableName, CF)) { List regions = UTIL.getAdmin().getRegions(tableName); - assertFalse("Table should have at least one region", regions.isEmpty()); + assertFalse(regions.isEmpty(), "Table should have at least one region"); List invalidRegionNames = Collections.singletonList(Bytes.toBytes("non-existent-region-name")); @@ -98,12 +93,12 @@ public void testInvalidRegionNamesThrowsException() throws Exception { UTIL.waitFor(60000, proc::isFailed); Throwable cause = ProcedureTestingUtility.getExceptionCause(proc); - assertTrue("Expected UnknownRegionException, got: " + cause.getClass().getName(), - cause instanceof UnknownRegionException); - assertTrue("Error message should contain region name", - cause.getMessage().contains("non-existent-region-name")); - assertTrue("Error message should contain table name", - cause.getMessage().contains(tableName.getNameAsString())); + assertTrue(cause instanceof UnknownRegionException, + "Expected UnknownRegionException, got: " + cause.getClass().getName()); + assertTrue(cause.getMessage().contains("non-existent-region-name"), + "Error message should contain region name"); + assertTrue(cause.getMessage().contains(tableName.getNameAsString()), + "Error message should contain table name"); } } @@ -113,7 +108,7 @@ public void testMixedValidInvalidRegions() throws Exception { try (Table ignored = UTIL.createTable(tableName, CF)) { List actualRegions = UTIL.getAdmin().getRegions(tableName); - assertFalse("Table should have at least one region", actualRegions.isEmpty()); + assertFalse(actualRegions.isEmpty(), "Table should have at least one region"); List mixedRegionNames = new ArrayList<>(); mixedRegionNames.add(actualRegions.get(0).getRegionName()); @@ -127,11 +122,11 @@ public void testMixedValidInvalidRegions() throws Exception { UTIL.waitFor(60000, proc::isFailed); Throwable cause = ProcedureTestingUtility.getExceptionCause(proc); - assertTrue("Expected UnknownRegionException", cause instanceof UnknownRegionException); - assertTrue("Error message should contain first invalid region", - cause.getMessage().contains("invalid-region-1")); - assertTrue("Error message should contain second invalid region", - cause.getMessage().contains("invalid-region-2")); + assertTrue(cause instanceof UnknownRegionException, "Expected UnknownRegionException"); + assertTrue(cause.getMessage().contains("invalid-region-1"), + "Error message should contain first invalid region"); + assertTrue(cause.getMessage().contains("invalid-region-2"), + "Error message should contain second invalid region"); } } @@ -158,10 +153,10 @@ public void testSpecificRegionsReopenWithThrottling() throws Exception { long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertFalse("Procedure should succeed", proc.isFailed()); - assertEquals("Should reopen exactly 3 regions", 3, proc.getRegionsReopened()); - assertTrue("Should process multiple batches with batch size 2", - proc.getBatchesProcessed() >= 2); + assertFalse(proc.isFailed(), "Procedure should succeed"); + assertEquals(3, proc.getRegionsReopened(), "Should reopen exactly 3 regions"); + assertTrue(proc.getBatchesProcessed() >= 2, + "Should process multiple batches with batch size 2"); } @Test @@ -182,8 +177,8 @@ public void testEmptyRegionListReopensAll() throws Exception { long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertFalse("Procedure should succeed", proc.isFailed()); - assertEquals("Should reopen all 5 regions", 5, proc.getRegionsReopened()); + assertFalse(proc.isFailed(), "Procedure should succeed"); + assertEquals(5, proc.getRegionsReopened(), "Should reopen all 5 regions"); } @Test @@ -198,9 +193,9 @@ public void testDisabledTableSkipsReopen() throws Exception { long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertFalse("Procedure should succeed", proc.isFailed()); - assertEquals("Should not reopen any regions for disabled table", 0, - proc.getRegionsReopened()); + assertFalse(proc.isFailed(), "Procedure should succeed"); + assertEquals(0, proc.getRegionsReopened(), + "Should not reopen any regions for disabled table"); } } @@ -224,9 +219,9 @@ public void testReopenRegionsThrottledWithLargeTable() throws Exception { long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertFalse("Procedure should succeed", proc.isFailed()); - assertEquals("Should reopen all 10 regions", 10, proc.getRegionsReopened()); - assertTrue("Should process multiple batches", proc.getBatchesProcessed() >= 4); + assertFalse(proc.isFailed(), "Procedure should succeed"); + assertEquals(10, proc.getRegionsReopened(), "Should reopen all 10 regions"); + assertTrue(proc.getBatchesProcessed() >= 4, "Should process multiple batches"); } @Test @@ -247,8 +242,8 @@ public void testConfigurationPrecedence() throws Exception { ReopenTableRegionsProcedure proc = ReopenTableRegionsProcedure.throttled(conf, UTIL.getAdmin().getDescriptor(tableName)); - assertEquals("Table descriptor config should override global config", 2000, - proc.getReopenBatchBackoffMillis()); + assertEquals(2000, proc.getReopenBatchBackoffMillis(), + "Table descriptor config should override global config"); } @Test @@ -268,13 +263,13 @@ public void testThrottledVsUnthrottled() throws Exception { ReopenTableRegionsProcedure unthrottledProc = new ReopenTableRegionsProcedure(tableName, regionNames); - assertEquals("Unthrottled should use default (0ms)", 0, - unthrottledProc.getReopenBatchBackoffMillis()); + assertEquals(0, unthrottledProc.getReopenBatchBackoffMillis(), + "Unthrottled should use default (0ms)"); ReopenTableRegionsProcedure throttledProc = ReopenTableRegionsProcedure .throttled(UTIL.getConfiguration(), UTIL.getAdmin().getDescriptor(tableName), regionNames); - assertEquals("Throttled should use table config (1000ms)", 1000, - throttledProc.getReopenBatchBackoffMillis()); + assertEquals(1000, throttledProc.getReopenBatchBackoffMillis(), + "Throttled should use table config (1000ms)"); } @Test @@ -292,10 +287,10 @@ public void testExceptionInProcedureExecution() throws Exception { UTIL.waitFor(60000, () -> getProcExec().isFinished(procId)); Procedure result = getProcExec().getResult(procId); - assertTrue("Procedure should have failed", result.isFailed()); + assertTrue(result.isFailed(), "Procedure should have failed"); Throwable cause = ProcedureTestingUtility.getExceptionCause(result); - assertTrue("Should be UnknownRegionException", cause instanceof UnknownRegionException); + assertTrue(cause instanceof UnknownRegionException, "Should be UnknownRegionException"); } } @@ -314,8 +309,8 @@ public void testSerializationWithRegionNames() throws Exception { long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertEquals("TableName should be preserved", tableName, proc.getTableName()); - assertEquals("Backoff should be preserved", 500L, proc.getReopenBatchBackoffMillis()); + assertEquals(tableName, proc.getTableName(), "TableName should be preserved"); + assertEquals(500L, proc.getReopenBatchBackoffMillis(), "Backoff should be preserved"); } } @@ -325,7 +320,7 @@ public void testAllRegionsWithValidNames() throws Exception { try (Table ignored = UTIL.createTable(tableName, CF)) { List actualRegions = UTIL.getAdmin().getRegions(tableName); - assertFalse("Table should have regions", actualRegions.isEmpty()); + assertFalse(actualRegions.isEmpty(), "Table should have regions"); List validRegionNames = actualRegions.stream().map(RegionInfo::getRegionName).collect(Collectors.toList()); @@ -336,9 +331,9 @@ public void testAllRegionsWithValidNames() throws Exception { long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertFalse("Procedure should succeed with all valid regions", proc.isFailed()); - assertEquals("Should reopen all specified regions", actualRegions.size(), - proc.getRegionsReopened()); + assertFalse(proc.isFailed(), "Procedure should succeed with all valid regions"); + assertEquals(actualRegions.size(), proc.getRegionsReopened(), + "Should reopen all specified regions"); } } @@ -357,9 +352,9 @@ public void testSingleInvalidRegion() throws Exception { UTIL.waitFor(60000, proc::isFailed); Throwable cause = ProcedureTestingUtility.getExceptionCause(proc); - assertTrue("Expected UnknownRegionException", cause instanceof UnknownRegionException); - assertTrue("Error message should list the invalid region", - cause.getMessage().contains("totally-fake-region")); + assertTrue(cause instanceof UnknownRegionException, "Expected UnknownRegionException"); + assertTrue(cause.getMessage().contains("totally-fake-region"), + "Error message should list the invalid region"); } } @@ -380,12 +375,12 @@ public void testRecoveryAfterValidationFailure() throws Exception { UTIL.waitFor(60000, () -> procExec.isFinished(procId)); Procedure result = procExec.getResult(procId); - assertTrue("Procedure should fail validation", result.isFailed()); + assertTrue(result.isFailed(), "Procedure should fail validation"); Throwable cause = ProcedureTestingUtility.getExceptionCause(result); - assertTrue("Should be UnknownRegionException", cause instanceof UnknownRegionException); - assertTrue("Error should mention the invalid region", - cause.getMessage().contains("invalid-for-recovery")); + assertTrue(cause instanceof UnknownRegionException, "Should be UnknownRegionException"); + assertTrue(cause.getMessage().contains("invalid-for-recovery"), + "Error should mention the invalid region"); } } @@ -407,8 +402,8 @@ public void testEmptyTableWithNoRegions() throws Exception { long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertFalse("Procedure should complete successfully even with no regions", proc.isFailed()); - assertEquals("Should handle empty table gracefully", regionCount, proc.getRegionsReopened()); + assertFalse(proc.isFailed(), "Procedure should complete successfully even with no regions"); + assertEquals(proc.getRegionsReopened(), regionCount, "Should handle empty table gracefully"); } @Test @@ -425,18 +420,18 @@ public void testConfigChangeDoesNotAffectRunningProcedure() throws Exception { ReopenTableRegionsProcedure proc = ReopenTableRegionsProcedure .throttled(UTIL.getConfiguration(), UTIL.getAdmin().getDescriptor(tableName)); - assertEquals("Initial config should be 1000ms", 1000L, proc.getReopenBatchBackoffMillis()); + assertEquals(1000L, proc.getReopenBatchBackoffMillis(), "Initial config should be 1000ms"); TableDescriptor modifiedTd = TableDescriptorBuilder.newBuilder(td) .setValue(ReopenTableRegionsProcedure.PROGRESSIVE_BATCH_BACKOFF_MILLIS_KEY, "5000").build(); UTIL.getAdmin().modifyTable(modifiedTd); - assertEquals("Running procedure should keep original config", 1000L, - proc.getReopenBatchBackoffMillis()); + assertEquals(1000L, proc.getReopenBatchBackoffMillis(), + "Running procedure should keep original config"); long procId = getProcExec().submitProcedure(proc); ProcedureTestingUtility.waitProcedure(getProcExec(), procId); - assertFalse("Procedure should complete successfully", proc.isFailed()); + assertFalse(proc.isFailed(), "Procedure should complete successfully"); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRestoreSnapshotProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRestoreSnapshotProcedure.java index 841964eb6ae3..bf05e3f9c87e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRestoreSnapshotProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRestoreSnapshotProcedure.java @@ -17,14 +17,13 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.TableNotDisabledException; import org.apache.hadoop.hbase.TableNotFoundException; @@ -42,28 +41,35 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestRestoreSnapshotProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRestoreSnapshotProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestRestoreSnapshotProcedure.class); + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } + + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } + protected final TableName snapshotTableName = TableName.valueOf("testRestoreSnapshot"); protected final byte[] CF1 = Bytes.toBytes("cf1"); protected final byte[] CF2 = Bytes.toBytes("cf2"); @@ -77,18 +83,21 @@ public class TestRestoreSnapshotProcedure extends TestTableDDLProcedureBase { private SnapshotProtos.SnapshotDescription snapshot = null; private TableDescriptor snapshotHTD = null; + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - @Before + @BeforeEach @Override public void setup() throws Exception { super.setup(); setupSnapshotAndUpdateTable(); } - @After + @AfterEach @Override public void tearDown() throws Exception { super.tearDown(); @@ -167,7 +176,7 @@ public void testRestoreSnapshot() throws Exception { @Test public void testRestoreSnapshotToDifferentTable() throws Exception { final ProcedureExecutor procExec = getMasterProcedureExecutor(); - final TableName restoredTableName = TableName.valueOf(name.getMethodName()); + final TableName restoredTableName = TableName.valueOf(testMethodName); final TableDescriptor tableDescriptor = createHTableDescriptor(restoredTableName, CF1, CF2); long procId = ProcedureTestingUtility.submitAndWait(procExec, diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCP.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCP.java index 23dd39b3c339..28fc0269bbf3 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCP.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCP.java @@ -17,10 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -32,18 +31,15 @@ import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCP extends TestSCPBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = HBaseClassTestRule.forClass(TestSCP.class); - private static final Logger LOG = LoggerFactory.getLogger(TestSCP.class); @Test @@ -58,7 +54,7 @@ public void testConcurrentSCPForSameServer() throws Exception { // Load the table with a bit of data so some logs to split and some edits in each region. this.util.loadTable(t, HBaseTestingUtil.COLUMNS[0]); final int count = HBaseTestingUtil.countRows(t); - assertTrue("expected some rows", count > 0); + assertTrue(count > 0, "expected some rows"); // find the first server that match the request and executes the test ServerName rsToKill = null; for (RegionInfo hri : util.getAdmin().getRegions(tableName)) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPBase.java index 15571e03c26f..858363a7acb6 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPBase.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPBase.java @@ -17,8 +17,8 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import org.apache.hadoop.conf.Configuration; @@ -33,8 +33,8 @@ import org.apache.hadoop.hbase.master.assignment.AssignmentTestingUtil; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; -import org.junit.After; -import org.junit.Before; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,7 +48,7 @@ protected void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); } - @Before + @BeforeEach public void setup() throws Exception { this.util = new HBaseTestingUtil(); setupConf(this.util.getConfiguration()); @@ -61,7 +61,7 @@ protected void startMiniCluster() throws Exception { this.util.startMiniCluster(RS_COUNT); } - @After + @AfterEach public void tearDown() throws Exception { SingleProcessHBaseCluster cluster = this.util.getHBaseCluster(); HMaster master = cluster == null ? null : cluster.getMaster(); @@ -84,7 +84,7 @@ protected void testRecoveryAndDoubleExecution(boolean carryingMeta, boolean doub // Load the table with a bit of data so some logs to split and some edits in each region. this.util.loadTable(t, HBaseTestingUtil.COLUMNS[0]); final int count = HBaseTestingUtil.countRows(t); - assertTrue("expected some rows", count > 0); + assertTrue(count > 0, "expected some rows"); final String checksum = util.checksumRows(t); // Run the procedure executor outside the master so we can mess with it. Need to disable // Master's running of the server crash processing. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMeta.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMeta.java index 11b2e512b680..f428aefbcfff 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMeta.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMeta.java @@ -17,20 +17,15 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithMeta extends TestSCPBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithMeta.class); - @Test public void testRecoveryAndDoubleExecutionOnRsWithMeta() throws Exception { testRecoveryAndDoubleExecution(true, true); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicas.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicas.java index e07ded0fbb8a..92468bab8a42 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicas.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicas.java @@ -17,19 +17,14 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithMetaWithReplicas extends TestSCPWithMeta { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithMetaWithReplicas.class); - @Override protected void startMiniCluster() throws Exception { // Start a cluster with 4 nodes because we have 3 replicas. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicasWithoutZKCoordinated.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicasWithoutZKCoordinated.java index 37d51ee042df..0948010573d8 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicasWithoutZKCoordinated.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithReplicasWithoutZKCoordinated.java @@ -18,20 +18,15 @@ package org.apache.hadoop.hbase.master.procedure; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithMetaWithReplicasWithoutZKCoordinated extends TestSCPWithMetaWithReplicas { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithMetaWithReplicasWithoutZKCoordinated.class); - @Override protected void setupConf(Configuration conf) { super.setupConf(conf); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithoutZKCoordinated.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithoutZKCoordinated.java index 9453a9e795da..dc4a623e42ee 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithoutZKCoordinated.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithMetaWithoutZKCoordinated.java @@ -18,20 +18,15 @@ package org.apache.hadoop.hbase.master.procedure; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithMetaWithoutZKCoordinated extends TestSCPWithMeta { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithMetaWithoutZKCoordinated.class); - @Override protected void setupConf(Configuration conf) { super.setupConf(conf); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicas.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicas.java index 24b398788a1c..604eddd25312 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicas.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicas.java @@ -17,19 +17,14 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithReplicas extends TestSCP { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithReplicas.class); - @Override protected void startMiniCluster() throws Exception { // Start a cluster with 4 nodes because we have 3 replicas. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithRSGroup.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithRSGroup.java index b500045d7c1a..8d9b82873f13 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithRSGroup.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithRSGroup.java @@ -18,24 +18,18 @@ package org.apache.hadoop.hbase.master.procedure; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; import org.apache.hadoop.hbase.master.LoadBalancer; import org.apache.hadoop.hbase.rsgroup.RSGroupAdminEndpoint; import org.apache.hadoop.hbase.rsgroup.RSGroupBasedLoadBalancer; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MediumTests.class }) +@Tag(MediumTests.TAG) public class TestSCPWithReplicasWithRSGroup extends TestSCPBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithReplicasWithRSGroup.class); - @Override protected void setupConf(Configuration conf) { conf.setClass(HConstants.HBASE_MASTER_LOADBALANCER_CLASS, RSGroupBasedLoadBalancer.class, diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithoutZKCoordinated.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithoutZKCoordinated.java index 5d4604677206..5b5488b3f940 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithoutZKCoordinated.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithReplicasWithoutZKCoordinated.java @@ -18,20 +18,15 @@ package org.apache.hadoop.hbase.master.procedure; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithReplicasWithoutZKCoordinated extends TestSCPWithReplicas { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithReplicasWithoutZKCoordinated.class); - @Override protected void setupConf(Configuration conf) { super.setupConf(conf); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMeta.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMeta.java index 2c8b74c76fa9..4844976cbf80 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMeta.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMeta.java @@ -17,20 +17,15 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithoutMeta extends TestSCPBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithoutMeta.class); - @Test public void testRecoveryAndDoubleExecutionOnRsWithoutMeta() throws Exception { testRecoveryAndDoubleExecution(false, true); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicas.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicas.java index 3a60f945d96f..f5557d09941f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicas.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicas.java @@ -17,19 +17,14 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithoutMetaWithReplicas extends TestSCPWithoutMeta { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithoutMetaWithReplicas.class); - @Override protected void startMiniCluster() throws Exception { // Start a cluster with 4 nodes because we have 3 replicas. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicasWithoutZKCoordinated.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicasWithoutZKCoordinated.java index 24fdd35afddb..30c660e8b40a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicasWithoutZKCoordinated.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithReplicasWithoutZKCoordinated.java @@ -18,21 +18,16 @@ package org.apache.hadoop.hbase.master.procedure; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithoutMetaWithReplicasWithoutZKCoordinated extends TestSCPWithoutMetaWithReplicas { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithoutMetaWithReplicasWithoutZKCoordinated.class); - @Override protected void setupConf(Configuration conf) { super.setupConf(conf); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithoutZKCoordinated.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithoutZKCoordinated.java index e51ff34de1e2..14f510da1403 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithoutZKCoordinated.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutMetaWithoutZKCoordinated.java @@ -18,20 +18,13 @@ package org.apache.hadoop.hbase.master.procedure; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) public class TestSCPWithoutMetaWithoutZKCoordinated extends TestSCPWithoutMeta { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithoutMetaWithoutZKCoordinated.class); - @Override protected void setupConf(Configuration conf) { super.setupConf(conf); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutZKCoordinated.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutZKCoordinated.java index b606082ddb1d..93d355ca94b9 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutZKCoordinated.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSCPWithoutZKCoordinated.java @@ -18,20 +18,15 @@ package org.apache.hadoop.hbase.master.procedure; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSCPWithoutZKCoordinated extends TestSCP { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSCPWithoutZKCoordinated.class); - @Override protected void setupConf(Configuration conf) { super.setupConf(conf); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSafemodeBringsDownMaster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSafemodeBringsDownMaster.java index 0d834ebc4471..314705e26d46 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSafemodeBringsDownMaster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSafemodeBringsDownMaster.java @@ -17,11 +17,10 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.Waiter; @@ -35,23 +34,18 @@ import org.apache.hadoop.hdfs.DistributedFileSystem; import org.apache.hadoop.hdfs.MiniDFSCluster; import org.apache.hadoop.hdfs.protocol.HdfsConstants; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category(MediumTests.class) +@Tag(MediumTests.TAG) public class TestSafemodeBringsDownMaster { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSafemodeBringsDownMaster.class); - private static final Logger LOG = LoggerFactory.getLogger(TestSafemodeBringsDownMaster.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -60,13 +54,13 @@ private static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(1); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); @@ -75,7 +69,7 @@ public static void cleanupTest() throws Exception { } } - @Before + @BeforeEach public void setup() throws Exception { resetProcExecutorTestingKillFlag(); } @@ -87,10 +81,10 @@ private ProcedureExecutor getMasterProcedureExecutor() { private void resetProcExecutorTestingKillFlag() { final ProcedureExecutor procExec = getMasterProcedureExecutor(); ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); - assertTrue("expected executor to be running", procExec.isRunning()); + assertTrue(procExec.isRunning(), "expected executor to be running"); } - @After + @AfterEach public void tearDown() throws Exception { } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSchedulerQueueDeadLock.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSchedulerQueueDeadLock.java index 49db85aea5e8..426ceb3cfde3 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSchedulerQueueDeadLock.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSchedulerQueueDeadLock.java @@ -19,7 +19,6 @@ import java.io.IOException; import java.util.concurrent.Semaphore; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.procedure2.Procedure; @@ -31,22 +30,17 @@ import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; - -@Category({ MasterTests.class, SmallTests.class }) +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; + +@Tag(MasterTests.TAG) +@Tag(SmallTests.TAG) public class TestSchedulerQueueDeadLock { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSchedulerQueueDeadLock.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static final TableName TABLE_NAME = TableName.valueOf("deadlock"); @@ -145,7 +139,7 @@ public TableOperationType getTableOperationType() { } } - @AfterClass + @AfterAll public static void tearDownAfterClass() throws IOException { UTIL.cleanupTestDir(); } @@ -154,14 +148,12 @@ public static void tearDownAfterClass() throws IOException { private ProcedureExecutor procExec; - @Rule - public final TestName name = new TestName(); - - @Before - public void setUp() throws IOException { + @BeforeEach + public void setUp(TestInfo testInfo) throws IOException { UTIL.getConfiguration().setInt("hbase.procedure.worker.stuck.threshold.msec", 6000000); + String testMethodName = testInfo.getTestMethod().get().getName(); procStore = ProcedureTestingUtility.createWalStore(UTIL.getConfiguration(), - UTIL.getDataTestDir(name.getMethodName())); + UTIL.getDataTestDir(testMethodName)); procStore.start(1); MasterProcedureScheduler scheduler = new MasterProcedureScheduler(pid -> null); procExec = new ProcedureExecutor<>(UTIL.getConfiguration(), new TestEnv(scheduler), procStore, @@ -169,10 +161,14 @@ public void setUp() throws IOException { procExec.init(1, false); } - @After + @AfterEach public void tearDown() { - procExec.stop(); - procStore.stop(false); + if (procExec != null) { + procExec.stop(); + } + if (procStore != null) { + procStore.stop(false); + } } public static final class TableSharedProcedureWithId extends TableSharedProcedure { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestServerRemoteProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestServerRemoteProcedure.java index f828f5ce1ba6..b53fea561597 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestServerRemoteProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestServerRemoteProcedure.java @@ -18,7 +18,9 @@ package org.apache.hadoop.hbase.master.procedure; import static org.apache.hadoop.hbase.master.procedure.ServerProcedureInterface.ServerOperationType.SWITCH_RPC_THROTTLE; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.util.Optional; @@ -29,7 +31,6 @@ import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -47,14 +48,11 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -62,14 +60,17 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestServerRemoteProcedure { private static final Logger LOG = LoggerFactory.getLogger(TestServerRemoteProcedure.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestServerRemoteProcedure.class); - @Rule - public TestName name = new TestName(); + private String testMethodName; + + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } + private HBaseTestingUtil util; private MockRSProcedureDispatcher rsDispatcher; private MockMasterServices master; @@ -77,7 +78,7 @@ public class TestServerRemoteProcedure { // Simple executor to run some simple tasks. private ScheduledExecutorService executor; - @Before + @BeforeEach public void setUp() throws Exception { util = new HBaseTestingUtil(); this.executor = Executors.newSingleThreadScheduledExecutor(new ThreadFactoryBuilder() @@ -91,7 +92,7 @@ public void setUp() throws Exception { .forEach(serverName -> am.getRegionStates().createServer(serverName)); } - @After + @AfterEach public void tearDown() throws Exception { master.stop("tearDown"); this.executor.shutdownNow(); @@ -108,7 +109,7 @@ public void testSplitWALAndCrashBeforeResponse() throws Exception { master.getServerManager().expireServer(worker); // if remoteCallFailed is called for this procedure, this procedure should be finished. future.get(5000, TimeUnit.MILLISECONDS); - Assert.assertTrue(splitWALRemoteProcedure.isSuccess()); + assertTrue(splitWALRemoteProcedure.isSuccess()); } @Test @@ -124,7 +125,7 @@ public void testRemoteCompleteAndFailedAtTheSameTime() throws Exception { threadPool.execute(() -> noopServerRemoteProcedure.remoteCallFailed( master.getMasterProcedureExecutor().getEnvironment(), worker, new IOException())); future.get(2000, TimeUnit.MILLISECONDS); - Assert.assertTrue(noopServerRemoteProcedure.isSuccess()); + assertTrue(noopServerRemoteProcedure.isSuccess()); } @Test @@ -146,7 +147,7 @@ public void testRegionOpenProcedureIsNotHandledByDispatcher() throws Exception { } catch (TimeoutException e) { LOG.info("timeout is expected"); } - Assert.assertFalse(openRegionProcedure.isFinished()); + assertFalse(openRegionProcedure.isFinished()); } private Future submitProcedure(final Procedure proc) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedure.java index 4d36080c5bd9..d336fa168127 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedure.java @@ -18,13 +18,12 @@ package org.apache.hadoop.hbase.master.procedure; import static org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SnapshotState.SNAPSHOT_SNAPSHOT_ONLINE_REGIONS; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.Optional; import java.util.concurrent.TimeUnit; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; @@ -39,13 +38,11 @@ import org.apache.hadoop.hbase.procedure2.RemoteProcedureDispatcher; import org.apache.hadoop.hbase.snapshot.SnapshotDescriptionUtils; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.RegionSplitter; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; import org.mockito.Mockito; import org.mockito.internal.stubbing.answers.AnswersWithDelay; import org.mockito.invocation.InvocationOnMock; @@ -58,14 +55,10 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SnapshotState; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) public class TestSnapshotProcedure { protected static final Logger LOG = LoggerFactory.getLogger(TestSnapshotProcedure.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedure.class); - protected static HBaseTestingUtil TEST_UTIL; protected HMaster master; protected TableName TABLE_NAME; @@ -96,7 +89,7 @@ protected Flow executeFromState(MasterProcedureEnv env, } } - @Before + @BeforeEach public void setup() throws Exception { TEST_UTIL = new HBaseTestingUtil(); Configuration config = TEST_UTIL.getConfiguration(); @@ -145,7 +138,7 @@ public Object answer(InvocationOnMock invocation) throws Throwable { return spySp; } - @After + @AfterEach public void teardown() throws Exception { if (this.master != null) { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(master.getMasterProcedureExecutor(), diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureBasicSnapshot.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureBasicSnapshot.java index 7e0545d81662..3b4e0df7f4df 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureBasicSnapshot.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureBasicSnapshot.java @@ -17,26 +17,22 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.client.SnapshotDescription; import org.apache.hadoop.hbase.client.SnapshotType; import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSnapshotProcedureBasicSnapshot extends TestSnapshotProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureBasicSnapshot.class); - @Test public void testSimpleSnapshotTable() throws Exception { TEST_UTIL.getAdmin().snapshot(snapshot); @@ -44,7 +40,7 @@ public void testSimpleSnapshotTable() throws Exception { SnapshotTestingUtils.confirmSnapshotValid(TEST_UTIL, snapshotProto, TABLE_NAME, CF); } - @Test(expected = org.apache.hadoop.hbase.snapshot.SnapshotCreationException.class) + @Test public void testClientTakingTwoSnapshotOnSameTable() throws Exception { Thread first = new Thread("first-client") { @Override @@ -62,10 +58,11 @@ public void run() { // we don't allow different snapshot with same name SnapshotDescription snapshotWithSameName = new SnapshotDescription(SNAPSHOT_NAME, TABLE_NAME, SnapshotType.SKIPFLUSH); - TEST_UTIL.getAdmin().snapshot(snapshotWithSameName); + assertThrows(org.apache.hadoop.hbase.snapshot.SnapshotCreationException.class, + () -> TEST_UTIL.getAdmin().snapshot(snapshotWithSameName)); } - @Test(expected = org.apache.hadoop.hbase.snapshot.SnapshotCreationException.class) + @Test public void testClientTakeSameSnapshotTwice() throws IOException, InterruptedException { Thread first = new Thread("first-client") { @Override @@ -80,6 +77,7 @@ public void run() { }; first.start(); Thread.sleep(1000); - TEST_UTIL.getAdmin().snapshot(snapshot); + assertThrows(org.apache.hadoop.hbase.snapshot.SnapshotCreationException.class, + () -> TEST_UTIL.getAdmin().snapshot(snapshot)); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureConcurrently.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureConcurrently.java index 74db32ccde13..24699850a4ad 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureConcurrently.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureConcurrently.java @@ -18,16 +18,15 @@ package org.apache.hadoop.hbase.master.procedure; import static org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.EnableTableState.ENABLE_TABLE_MARK_REGIONS_ONLINE; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.util.Arrays; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.SnapshotDescription; import org.apache.hadoop.hbase.client.SnapshotType; @@ -38,21 +37,17 @@ import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSnapshotProcedureConcurrently extends TestSnapshotProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureConcurrently.class); - @Test public void testRunningTwoSnapshotProcedureOnSameTable() throws Exception { String newSnapshotName = SNAPSHOT_NAME + "_2"; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureEarlyExpiration.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureEarlyExpiration.java index 6af415f5438b..903d3b9d9302 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureEarlyExpiration.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureEarlyExpiration.java @@ -17,14 +17,13 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.SnapshotDescription; @@ -38,22 +37,19 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.RegionSplitter; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SnapshotState; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSnapshotProcedureEarlyExpiration extends TestSnapshotProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureEarlyExpiration.class); - @Before + @BeforeEach @Override public void setup() throws Exception { // Copied from TestSnapshotProcedure with modified // SnapshotDescription diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureForSnapshotType.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureForSnapshotType.java index c1497d75a161..547f9765f320 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureForSnapshotType.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureForSnapshotType.java @@ -17,12 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.Optional; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; @@ -32,26 +31,25 @@ import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSnapshotProcedureForSnapshotType extends TestSnapshotProcedure { + private String testMethodName; - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureForSnapshotType.class); - - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } @Test public void testSnapshotTypeForEnabledTable() throws IOException { - TableName tableName = TableName.valueOf(name.getMethodName()); - String snapshotName = "snapshot_" + name.getMethodName(); + TableName tableName = TableName.valueOf(testMethodName); + String snapshotName = "snapshot_" + testMethodName; TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(tableName); ColumnFamilyDescriptor columnFamilyDescriptor = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("info")).build(); @@ -70,8 +68,8 @@ public void testSnapshotTypeForEnabledTable() throws IOException { @Test public void testSnapshotTypeForDisabledTable() throws IOException { - TableName tableName = TableName.valueOf(name.getMethodName()); - String snapshotName = "snapshot_" + name.getMethodName(); + TableName tableName = TableName.valueOf(testMethodName); + String snapshotName = "snapshot_" + testMethodName; TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(tableName); ColumnFamilyDescriptor columnFamilyDescriptor = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes("info")).build(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureMasterRestarts.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureMasterRestarts.java index 9d3a7811321b..07406671f92a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureMasterRestarts.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureMasterRestarts.java @@ -17,13 +17,12 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import java.util.stream.Collectors; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; @@ -31,20 +30,16 @@ import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SnapshotState; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestSnapshotProcedureMasterRestarts extends TestSnapshotProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureMasterRestarts.class); - @Test public void testMasterRestarts() throws Exception { ProcedureExecutor procExec = master.getMasterProcedureExecutor(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRIT.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRIT.java index e7cfeae324e7..b1767b3fda91 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRIT.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRIT.java @@ -19,7 +19,6 @@ import java.util.List; import java.util.stream.Collectors; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.master.assignment.MergeTableRegionsProcedure; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; @@ -27,19 +26,15 @@ import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestSnapshotProcedureRIT extends TestSnapshotProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureRIT.class); - @Test public void testTableInMergeWhileTakingSnapshot() throws Exception { ProcedureExecutor procExec = master.getMasterProcedureExecutor(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRSCrashes.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRSCrashes.java index 2b06a56fbc50..035b0412a15f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRSCrashes.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureRSCrashes.java @@ -17,7 +17,6 @@ */ package org.apache.hadoop.hbase.master.procedure; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; @@ -25,17 +24,13 @@ import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSnapshotProcedureRSCrashes extends TestSnapshotProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureRSCrashes.class); - @Test public void testRegionServerCrashWhileTakingSnapshot() throws Exception { ProcedureExecutor procExec = master.getMasterProcedureExecutor(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureSnapshotCorrupted.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureSnapshotCorrupted.java index da7bf8629fa7..24a4c532962d 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureSnapshotCorrupted.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureSnapshotCorrupted.java @@ -17,13 +17,12 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Optional; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.snapshot.SnapshotDescriptionUtils; @@ -31,19 +30,15 @@ import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hdfs.DistributedFileSystem; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SnapshotState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestSnapshotProcedureSnapshotCorrupted extends TestSnapshotProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureSnapshotCorrupted.class); - @Test public void testSnapshotCorruptedAndRollback() throws Exception { ProcedureExecutor procExec = master.getMasterProcedureExecutor(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureWithLockTimeout.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureWithLockTimeout.java index f780d68acf49..23601488c5a5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureWithLockTimeout.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotProcedureWithLockTimeout.java @@ -17,12 +17,11 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.SnapshotDescription; @@ -36,11 +35,10 @@ import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.RegionSplitter; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -51,23 +49,20 @@ /** * Snapshot creation with master lock timeout test. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestSnapshotProcedureWithLockTimeout { private static final Logger LOG = LoggerFactory.getLogger(TestSnapshotProcedureWithLockTimeout.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotProcedureWithLockTimeout.class); - private static HBaseTestingUtil TEST_UTIL; private HMaster master; private TableName TABLE_NAME; private byte[] CF; private String SNAPSHOT_NAME; - @Before + @BeforeEach public void setup() throws Exception { TEST_UTIL = new HBaseTestingUtil(); Configuration config = TEST_UTIL.getConfiguration(); @@ -83,7 +78,7 @@ public void setup() throws Exception { TEST_UTIL.loadTable(table, CF, false); } - @After + @AfterEach public void teardown() throws Exception { if (this.master != null) { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(master.getMasterProcedureExecutor(), @@ -105,7 +100,7 @@ public void testTakeZkCoordinatedSnapshot() { } catch (Exception e) { LOG.error("Error because of faster lock acquisition. retrying....", e); } - assertNotEquals("Retries exhausted", 9, i); + assertNotEquals(9, i, "Retries exhausted"); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotRegionProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotRegionProcedure.java index 4db3e638a45c..8eaf8340414b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotRegionProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotRegionProcedure.java @@ -17,14 +17,13 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -44,25 +43,21 @@ import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.Pair; import org.apache.hadoop.hbase.util.RegionSplitter; -import org.junit.After; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestSnapshotRegionProcedure { private static final Logger LOG = LoggerFactory.getLogger(TestSnapshotRegionProcedure.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotRegionProcedure.class); - private static HBaseTestingUtil TEST_UTIL; private HMaster master; private TableName tableName; @@ -70,7 +65,7 @@ public class TestSnapshotRegionProcedure { private Path workingDir; private FileSystem workingDirFs; - @Before + @BeforeEach public void setup() throws Exception { TEST_UTIL = new HBaseTestingUtil(); Configuration conf = TEST_UTIL.getConfiguration(); @@ -138,7 +133,7 @@ public void testRegionServerCrashWhileTakingSnapshotRegion() throws Exception { assertTrue(assertRegionManifestGenerated(pair.getFirst())); } - @After + @AfterEach public void teardown() throws Exception { if (this.master != null) { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(master.getMasterProcedureExecutor(), diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotVerifyProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotVerifyProcedure.java index e16cd17d07fd..749f1de0bc0f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotVerifyProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSnapshotVerifyProcedure.java @@ -17,12 +17,16 @@ */ package org.apache.hadoop.hbase.master.procedure; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.io.IOException; import java.util.Optional; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -44,26 +48,21 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.RegionSplitter; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; -@Category({ RegionServerTests.class, LargeTests.class }) +@Tag(RegionServerTests.TAG) +@Tag(LargeTests.TAG) public class TestSnapshotVerifyProcedure { private static final Logger LOG = LoggerFactory.getLogger(TestSnapshotVerifyProcedure.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSnapshotVerifyProcedure.class); - private HBaseTestingUtil TEST_UTIL; private final TableName tableName = TableName.valueOf("TestRSSnapshotVerifier"); private final byte[] cf = Bytes.toBytes("cf"); @@ -72,7 +71,7 @@ public class TestSnapshotVerifyProcedure { private SnapshotProtos.SnapshotDescription snapshotProto = ProtobufUtil.createHBaseProtosSnapshotDesc(snapshot); - @Before + @BeforeEach public void setup() throws Exception { TEST_UTIL = new HBaseTestingUtil(); Configuration conf = TEST_UTIL.getConfiguration(); @@ -113,14 +112,14 @@ public void setup() throws Exception { public void testSimpleVerify() throws Exception { Optional regionOpt = TEST_UTIL.getHBaseCluster().getRegions(tableName).stream() .filter(r -> !r.getStore(cf).getStorefiles().isEmpty()).findFirst(); - Assert.assertTrue(regionOpt.isPresent()); + assertTrue(regionOpt.isPresent()); HRegion region = regionOpt.get(); SnapshotVerifyProcedure p1 = new SnapshotVerifyProcedure(snapshotProto, region.getRegionInfo()); ProcedureExecutor procExec = TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor(); long procId = procExec.submitProcedure(p1); ProcedureTestingUtility.waitProcedure(procExec, procId); - Assert.assertTrue(p1.isSuccess()); + assertTrue(p1.isSuccess()); // delete store file to trigger a CorruptedSnapshotException for (HStoreFile file : region.getStore(cf).getStorefiles()) { @@ -130,7 +129,7 @@ public void testSimpleVerify() throws Exception { SnapshotVerifyProcedure p2 = new SnapshotVerifyProcedure(snapshotProto, region.getRegionInfo()); long newProcId = procExec.submitProcedure(p2); ProcedureTestingUtility.waitProcedure(procExec, newProcId); - Assert.assertTrue(p2.isSuccess()); + assertTrue(p2.isSuccess()); } @Test @@ -153,20 +152,18 @@ public void testRestartMaster() throws Exception { master = TEST_UTIL.getHBaseCluster().getMaster(); SnapshotVerifyProcedure svp2 = master.getMasterProcedureExecutor().getProcedure(SnapshotVerifyProcedure.class, procId); - Assert.assertNotNull(svp2); - Assert.assertFalse(svp2.isFinished()); - Assert.assertNotNull(svp2.getServerName()); - Assert.assertEquals(worker, svp.getServerName()); - Assert.assertEquals((int) master.getSnapshotManager().getAvailableWorker(worker), - availableWorker); + assertNotNull(svp2); + assertFalse(svp2.isFinished()); + assertNotNull(svp2.getServerName()); + assertEquals(worker, svp.getServerName()); + assertEquals((int) master.getSnapshotManager().getAvailableWorker(worker), availableWorker); // release worker ProcedureTestingUtility.waitProcedure(master.getMasterProcedureExecutor(), svp2); - Assert.assertEquals((int) master.getSnapshotManager().getAvailableWorker(worker), - availableWorker + 1); + assertEquals((int) master.getSnapshotManager().getAvailableWorker(worker), availableWorker + 1); } - @After + @AfterEach public void teardown() throws Exception { TEST_UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSplitWALProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSplitWALProcedure.java index dbd2d5ece794..c5363fea79f6 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSplitWALProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSplitWALProcedure.java @@ -19,11 +19,14 @@ import static org.apache.hadoop.hbase.HConstants.HBASE_SPLIT_WAL_COORDINATED_BY_ZK; import static org.apache.hadoop.hbase.HConstants.HBASE_SPLIT_WAL_MAX_SPLITTER; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import java.util.Optional; import org.apache.hadoop.fs.FileStatus; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; @@ -37,18 +40,14 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestSplitWALProcedure { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSplitWALProcedure.class); private static HBaseTestingUtil TEST_UTIL; private HMaster master; @@ -56,7 +55,7 @@ public class TestSplitWALProcedure { private SplitWALManager splitWALManager; private byte[] FAMILY; - @Before + @BeforeEach public void setup() throws Exception { TEST_UTIL = new HBaseTestingUtil(); TEST_UTIL.getConfiguration().setBoolean(HBASE_SPLIT_WAL_COORDINATED_BY_ZK, false); @@ -68,7 +67,7 @@ public void setup() throws Exception { FAMILY = Bytes.toBytes("test"); } - @After + @AfterEach public void teardown() throws Exception { if (this.master != null) { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(master.getMasterProcedureExecutor(), @@ -86,18 +85,18 @@ public void testHandleDeadWorker() throws Exception { HRegionServer testServer = TEST_UTIL.getHBaseCluster().getRegionServer(0); ProcedureExecutor masterPE = master.getMasterProcedureExecutor(); List wals = splitWALManager.getWALsToSplit(testServer.getServerName(), false); - Assert.assertEquals(1, wals.size()); + assertEquals(1, wals.size()); TEST_UTIL.getHBaseCluster().killRegionServer(testServer.getServerName()); TEST_UTIL.waitFor(30000, () -> master.getProcedures().stream() .anyMatch(procedure -> procedure instanceof SplitWALProcedure)); Procedure splitWALProcedure = master.getProcedures().stream() .filter(procedure -> procedure instanceof SplitWALProcedure).findAny().get(); - Assert.assertNotNull(splitWALProcedure); + assertNotNull(splitWALProcedure); TEST_UTIL.waitFor(5000, () -> ((SplitWALProcedure) splitWALProcedure).getWorker() != null); TEST_UTIL.getHBaseCluster() .killRegionServer(((SplitWALProcedure) splitWALProcedure).getWorker()); ProcedureTestingUtility.waitProcedure(masterPE, splitWALProcedure.getProcId()); - Assert.assertTrue(splitWALProcedure.isSuccess()); + assertTrue(splitWALProcedure.isSuccess()); ProcedureTestingUtility.waitAllProcedures(masterPE); } @@ -109,7 +108,7 @@ public void testMasterRestart() throws Exception { } HRegionServer testServer = TEST_UTIL.getHBaseCluster().getRegionServer(0); List wals = splitWALManager.getWALsToSplit(testServer.getServerName(), false); - Assert.assertEquals(1, wals.size()); + assertEquals(1, wals.size()); SplitWALProcedure splitWALProcedure = new SplitWALProcedure(wals.get(0).getPath().toString(), testServer.getServerName()); long pid = ProcedureTestingUtility.submitProcedure(master.getMasterProcedureExecutor(), @@ -126,9 +125,9 @@ public void testMasterRestart() throws Exception { Optional> procedure = master.getProcedures().stream().filter(p -> p.getProcId() == pid).findAny(); // make sure procedure is successful and wal is deleted - Assert.assertTrue(procedure.isPresent()); - Assert.assertTrue(procedure.get().isSuccess()); - Assert.assertFalse(TEST_UTIL.getTestFileSystem().exists(wals.get(0).getPath())); + assertTrue(procedure.isPresent()); + assertTrue(procedure.get().isSuccess()); + assertFalse(TEST_UTIL.getTestFileSystem().exists(wals.get(0).getPath())); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSuspendTRSPWhenHoldingRegionStateNodeLock.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSuspendTRSPWhenHoldingRegionStateNodeLock.java index 39427d25b100..14f49f42755b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSuspendTRSPWhenHoldingRegionStateNodeLock.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestSuspendTRSPWhenHoldingRegionStateNodeLock.java @@ -19,10 +19,9 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.everyItem; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -39,31 +38,27 @@ import org.hamcrest.BaseMatcher; import org.hamcrest.Description; import org.hamcrest.Matcher; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hbase.thirdparty.com.google.common.collect.Iterables; /** * Testcase for HBASE-28240. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestSuspendTRSPWhenHoldingRegionStateNodeLock { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSuspendTRSPWhenHoldingRegionStateNodeLock.class); - private static final HBaseTestingUtil HBTU = new HBaseTestingUtil(); private static TableName TABLE_NAME = TableName.valueOf("test"); private static byte[] FAMILY = Bytes.toBytes("family"); - @BeforeClass + @BeforeAll public static void setUp() throws Exception { HBTU.startMiniCluster(2); HBTU.createTable(TABLE_NAME, FAMILY); @@ -72,7 +67,7 @@ public static void setUp() throws Exception { HBTU.waitUntilNoRegionsInTransition(); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { HBTU.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDDLProcedureBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDDLProcedureBase.java index b474a3df6047..ee621ab20a27 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDDLProcedureBase.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDDLProcedureBase.java @@ -17,7 +17,7 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseTestingUtil; @@ -25,10 +25,8 @@ import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -36,18 +34,16 @@ public abstract class TestTableDDLProcedureBase { private static final Logger LOG = LoggerFactory.getLogger(TestTableDDLProcedureBase.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); - private static void setupConf(Configuration conf) { + protected static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); } - @BeforeClass - public static void setupCluster() throws Exception { + protected static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(1); } - @AfterClass - public static void cleanupTest() throws Exception { + protected static void cleanupTest() throws Exception { try { UTIL.shutdownMiniCluster(); } catch (Exception e) { @@ -55,12 +51,12 @@ public static void cleanupTest() throws Exception { } } - @Before + @BeforeEach public void setup() throws Exception { resetProcExecutorTestingKillFlag(); } - @After + @AfterEach public void tearDown() throws Exception { resetProcExecutorTestingKillFlag(); for (TableDescriptor htd : UTIL.getAdmin().listTableDescriptors()) { @@ -72,7 +68,7 @@ public void tearDown() throws Exception { protected void resetProcExecutorTestingKillFlag() { final ProcedureExecutor procExec = getMasterProcedureExecutor(); ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); - assertTrue("expected executor to be running", procExec.isRunning()); + assertTrue(procExec.isRunning(), "expected executor to be running"); } protected ProcedureExecutor getMasterProcedureExecutor() { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDescriptorModificationFromClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDescriptorModificationFromClient.java index 6f95aa43657f..d5e72e4589cb 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDescriptorModificationFromClient.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableDescriptorModificationFromClient.java @@ -17,13 +17,13 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.util.Set; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.InvalidFamilyOperationException; import org.apache.hadoop.hbase.TableName; @@ -38,29 +38,20 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.FSTableDescriptors; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; /** * Verify that the HTableDescriptor is updated after addColumn(), deleteColumn() and modifyTable() * operations. */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestTableDescriptorModificationFromClient { - - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestTableDescriptorModificationFromClient.class); - - @Rule - public TestName name = new TestName(); private static final HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil(); private static TableName TABLE_NAME = null; private static final byte[] FAMILY_0 = Bytes.toBytes("cf0"); @@ -69,18 +60,17 @@ public class TestTableDescriptorModificationFromClient { /** * Start up a mini cluster and put a small table of empty regions into it. */ - @BeforeClass + @BeforeAll public static void beforeAllTests() throws Exception { TEST_UTIL.startMiniCluster(1); } - @Before - public void setup() { - TABLE_NAME = TableName.valueOf(name.getMethodName()); - + @BeforeEach + public void setup(TestInfo testInfo) { + TABLE_NAME = TableName.valueOf(testInfo.getTestMethod().get().getName()); } - @AfterClass + @AfterAll public static void afterAllTests() throws Exception { TEST_UTIL.shutdownMiniCluster(); } @@ -147,7 +137,7 @@ public void testAddSameColumnFamilyTwice() throws IOException { try { // Add same column family again - expect failure admin.addColumnFamily(TABLE_NAME, ColumnFamilyDescriptorBuilder.of(FAMILY_1)); - Assert.fail("Delete a non-exist column family should fail"); + fail("Delete a non-exist column family should fail"); } catch (InvalidFamilyOperationException e) { // Expected. } @@ -209,7 +199,7 @@ public void testModifyNonExistingColumnFamily() throws IOException { // Modify a column family that is not in the table. try { admin.modifyColumnFamily(TABLE_NAME, cfDescriptor); - Assert.fail("Modify a non-exist column family should fail"); + fail("Modify a non-exist column family should fail"); } catch (InvalidFamilyOperationException e) { // Expected. } @@ -260,7 +250,7 @@ public void testDeleteSameColumnFamilyTwice() throws IOException { try { // Delete again - expect failure admin.deleteColumnFamily(TABLE_NAME, FAMILY_1); - Assert.fail("Delete a non-exist column family should fail"); + fail("Delete a non-exist column family should fail"); } catch (Exception e) { // Expected. } @@ -290,7 +280,7 @@ private void verifyTableDescriptor(final TableDescriptor htd, final TableName ta assertEquals(tableName, htd.getTableName()); assertEquals(families.length, htdFamilies.size()); for (byte[] familyName : families) { - assertTrue("Expected family " + Bytes.toString(familyName), htdFamilies.contains(familyName)); + assertTrue(htdFamilies.contains(familyName), "Expected family " + Bytes.toString(familyName)); } } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableProcedureWaitingQueueCleanup.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableProcedureWaitingQueueCleanup.java index 386356124f5b..66841c23d0bc 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableProcedureWaitingQueueCleanup.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTableProcedureWaitingQueueCleanup.java @@ -17,10 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; @@ -36,22 +35,18 @@ import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; /** * Testcase for HBASE-28876 */ -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestTableProcedureWaitingQueueCleanup { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestTableProcedureWaitingQueueCleanup.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); private static TableDescriptor TD = TableDescriptorBuilder.newBuilder(TableName.valueOf("test")) @@ -104,12 +99,12 @@ public PeerOperationType getPeerOperationType() { } } - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.startMiniCluster(); } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedure.java index 8ea493984e69..2b0cf886ad23 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedure.java @@ -18,15 +18,14 @@ package org.apache.hadoop.hbase.master.procedure; import static org.apache.hadoop.hbase.master.assignment.AssignmentTestingUtil.insertData; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; @@ -41,53 +40,48 @@ import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; @SuppressWarnings("OptionalGetWithoutIsPresent") -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestTruncateRegionProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestTruncateRegionProcedure.class); private static final Logger LOG = LoggerFactory.getLogger(TestTruncateRegionProcedure.class); + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - private static void setupConf(Configuration conf) { + protected static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); conf.setLong(HConstants.MAJOR_COMPACTION_PERIOD, 0); conf.setInt("hbase.client.sync.wait.timeout.msec", 60000); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(3); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { - try { - UTIL.shutdownMiniCluster(); - } catch (Exception e) { - LOG.warn("failure shutting down cluster", e); - } + TestTableDDLProcedureBase.cleanupTest(); } - @Before + @BeforeEach public void setup() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); @@ -97,7 +91,7 @@ public void setup() throws Exception { UTIL.getHBaseCluster().getMaster().setCatalogJanitorEnabled(false); } - @After + @AfterEach public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); for (TableDescriptor htd : UTIL.getAdmin().listTableDescriptors()) { @@ -109,7 +103,7 @@ public void tearDown() throws Exception { public void testTruncateRegionProcedure() throws Exception { final ProcedureExecutor procExec = getMasterProcedureExecutor(); // Arrange - Load table and prepare arguments values. - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String[] families = new String[] { "f1", "f2" }; final byte[][] splitKeys = new byte[][] { Bytes.toBytes("30"), Bytes.toBytes("60"), Bytes.toBytes("90") }; @@ -137,8 +131,8 @@ public void testTruncateRegionProcedure() throws Exception { assertEquals(8 - 2, UTIL.countRows(tableName)); int rowsAfterDropRegion = UTIL.countRows(tableName); - assertTrue("Row counts after truncate region should be less than row count before it", - rowsAfterDropRegion < rowsBeforeDropRegion); + assertTrue(rowsAfterDropRegion < rowsBeforeDropRegion, + "Row counts after truncate region should be less than row count before it"); assertEquals(rowsBeforeDropRegion, rowsAfterDropRegion + 2); insertData(UTIL, tableName, 2, 20, families); @@ -149,7 +143,7 @@ public void testTruncateRegionProcedure() throws Exception { public void testTruncateRegionProcedureErrorWhenSpecifiedReplicaRegionID() throws Exception { final ProcedureExecutor procExec = getMasterProcedureExecutor(); // Arrange - Load table and prepare arguments values. - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String[] families = new String[] { "f1", "f2" }; createTable(tableName, families, 2); insertData(UTIL, tableName, 2, 20, families); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedureWithRecovery.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedureWithRecovery.java index 15023d48f247..85a619a930ea 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedureWithRecovery.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateRegionProcedureWithRecovery.java @@ -18,11 +18,10 @@ package org.apache.hadoop.hbase.master.procedure; import static org.apache.hadoop.hbase.master.assignment.AssignmentTestingUtil.insertData; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; @@ -35,54 +34,49 @@ import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TruncateRegionState; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestTruncateRegionProcedureWithRecovery extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestTruncateRegionProcedureWithRecovery.class); private static final Logger LOG = LoggerFactory.getLogger(TestTruncateRegionProcedureWithRecovery.class); + private String testMethodName; - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - private static void setupConf(Configuration conf) { + protected static void setupConf(Configuration conf) { conf.setInt(MasterProcedureConstants.MASTER_PROCEDURE_THREADS, 1); conf.setLong(HConstants.MAJOR_COMPACTION_PERIOD, 0); conf.setBoolean(HConstants.SNAPSHOT_BEFORE_DESTRUCTIVE_ACTION_ENABLED_KEY, true); conf.setInt("hbase.client.sync.wait.timeout.msec", 60000); } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { setupConf(UTIL.getConfiguration()); UTIL.startMiniCluster(3); } - @AfterClass + @AfterAll public static void cleanupTest() throws Exception { - try { - UTIL.shutdownMiniCluster(); - } catch (Exception e) { - LOG.warn("failure shutting down cluster", e); - } + TestTableDDLProcedureBase.cleanupTest(); } - @Before + @BeforeEach public void setup() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); @@ -92,7 +86,7 @@ public void setup() throws Exception { UTIL.getHBaseCluster().getMaster().setCatalogJanitorEnabled(false); } - @After + @AfterEach public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); for (TableDescriptor htd : UTIL.getAdmin().listTableDescriptors()) { @@ -102,7 +96,7 @@ public void tearDown() throws Exception { @Test public void testRecoverySnapshotRollback() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String[] families = new String[] { "f1", "f2" }; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -130,7 +124,7 @@ public void testRecoverySnapshotRollback() throws Exception { // Wait for procedure to complete (should fail) ProcedureTestingUtility.waitProcedure(procExec, procId); Procedure result = procExec.getResult(procId); - assertTrue("Procedure should have failed", result.isFailed()); + assertTrue(result.isFailed(), "Procedure should have failed"); // Verify no recovery snapshots remain after rollback boolean snapshotFound = false; @@ -140,13 +134,13 @@ public void testRecoverySnapshotRollback() throws Exception { break; } } - assertTrue("Recovery snapshot should have been cleaned up during rollback", !snapshotFound); + assertTrue(!snapshotFound, "Recovery snapshot should have been cleaned up during rollback"); } @Test public void testRecoverySnapshotAndRestore() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); - final TableName restoredTableName = TableName.valueOf(name.getMethodName() + "_restored"); + final TableName tableName = TableName.valueOf(testMethodName); + final TableName restoredTableName = TableName.valueOf(testMethodName + "_restored"); final String[] families = new String[] { "f1", "f2" }; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -174,7 +168,7 @@ public void testRecoverySnapshotAndRestore() throws Exception { // Verify region is truncated (should have fewer rows) int rowsAfterTruncate = UTIL.countRows(tableName); - assertTrue("Should have fewer rows after truncate", rowsAfterTruncate < initialRowCount); + assertTrue(rowsAfterTruncate < initialRowCount, "Should have fewer rows after truncate"); // Find the recovery snapshot String recoverySnapshotName = null; @@ -184,15 +178,15 @@ public void testRecoverySnapshotAndRestore() throws Exception { break; } } - assertTrue("Recovery snapshot should exist", recoverySnapshotName != null); + assertTrue(recoverySnapshotName != null, "Recovery snapshot should exist"); // Restore from snapshot by cloning to a new table UTIL.getAdmin().cloneSnapshot(recoverySnapshotName, restoredTableName); UTIL.waitUntilAllRegionsAssigned(restoredTableName); // Verify restored table has original data - assertEquals("Restored table should have original data", initialRowCount, - UTIL.countRows(restoredTableName)); + assertEquals(initialRowCount, UTIL.countRows(restoredTableName), + "Restored table should have original data"); // Clean up the cloned table UTIL.getAdmin().disableTable(restoredTableName); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedure.java index 794e98037e37..09cd57fd6184 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedure.java @@ -17,9 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.util.Arrays; @@ -27,7 +27,6 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.TableNotDisabledException; @@ -46,31 +45,42 @@ import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.FSUtils; import org.apache.hadoop.hbase.util.ModifyRegionUtils; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestTruncateTableProcedure extends TestTableDDLProcedureBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestTruncateTableProcedure.class); - private static final Logger LOG = LoggerFactory.getLogger(TestTruncateTableProcedure.class); + private String testMethodName; + + @BeforeAll + public static void setupCluster() throws Exception { + TestTableDDLProcedureBase.setupCluster(); + } - @Rule - public TestName name = new TestName(); + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); + } + + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } @Test public void testTruncateNotExistentTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); // HBASE-20178 has us fail-fast, in the constructor, so add try/catch for this case. @@ -93,7 +103,7 @@ public void testTruncateNotExistentTable() throws Exception { @Test public void testTruncateNotDisabledTable() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final ProcedureExecutor procExec = getMasterProcedureExecutor(); MasterProcedureTestingUtility.createTable(procExec, tableName, null, "f"); @@ -118,13 +128,13 @@ public void testTruncateNotDisabledTable() throws Exception { @Test public void testSimpleTruncatePreserveSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testSimpleTruncate(tableName, true); } @Test public void testSimpleTruncateNoPreserveSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testSimpleTruncate(tableName, false); } @@ -174,13 +184,13 @@ private void testSimpleTruncate(final TableName tableName, final boolean preserv @Test public void testRecoveryAndDoubleExecutionPreserveSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testRecoveryAndDoubleExecution(tableName, true); } @Test public void testRecoveryAndDoubleExecutionNoPreserveSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testRecoveryAndDoubleExecution(tableName, false); } @@ -236,13 +246,13 @@ private void testRecoveryAndDoubleExecution(final TableName tableName, @Test public void testOnHDFSFailurePreserveSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testOnHDFSFailure(tableName, true); } @Test public void testOnHDFSFailureNoPreserveSplits() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); testOnHDFSFailure(tableName, false); } @@ -320,7 +330,7 @@ public void testTruncateWithPreserveAfterSplit() throws Exception { String[] families = new String[] { "f1", "f2" }; byte[][] splitKeys = new byte[][] { Bytes.toBytes("a"), Bytes.toBytes("b"), Bytes.toBytes("c") }; - TableName tableName = TableName.valueOf(name.getMethodName()); + TableName tableName = TableName.valueOf(testMethodName); RegionInfo[] regions = MasterProcedureTestingUtility.createTable(getMasterProcedureExecutor(), tableName, splitKeys, families); splitAndTruncate(tableName, regions, 1); @@ -331,7 +341,7 @@ public void testTruncatePreserveWithReplicaRegionAfterSplit() throws Exception { String[] families = new String[] { "f1", "f2" }; byte[][] splitKeys = new byte[][] { Bytes.toBytes("a"), Bytes.toBytes("b"), Bytes.toBytes("c") }; - TableName tableName = TableName.valueOf(name.getMethodName()); + TableName tableName = TableName.valueOf(testMethodName); // create a table with region replications TableDescriptor htd = TableDescriptorBuilder.newBuilder(tableName).setRegionReplication(3) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedureWithRecovery.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedureWithRecovery.java index 34ffabc58548..fa6aef50ea32 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedureWithRecovery.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableProcedureWithRecovery.java @@ -17,10 +17,9 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; @@ -30,36 +29,42 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MasterTests; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInfo; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TruncateTableState; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestTruncateTableProcedureWithRecovery extends TestTableDDLProcedureBase { + private String testMethodName; - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestTruncateTableProcedureWithRecovery.class); - - @Rule - public TestName name = new TestName(); + @BeforeEach + public void setTestMethod(TestInfo testInfo) { + testMethodName = testInfo.getTestMethod().get().getName(); + } - @BeforeClass + @BeforeAll public static void setupCluster() throws Exception { // Enable recovery snapshots + TestTableDDLProcedureBase.setupConf(UTIL.getConfiguration()); UTIL.getConfiguration().setBoolean(HConstants.SNAPSHOT_BEFORE_DESTRUCTIVE_ACTION_ENABLED_KEY, true); - TestTableDDLProcedureBase.setupCluster(); + UTIL.startMiniCluster(1); + } + + @AfterAll + public static void cleanupTest() throws Exception { + TestTableDDLProcedureBase.cleanupTest(); } @Test public void testRecoverySnapshotRollback() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); + final TableName tableName = TableName.valueOf(testMethodName); final String[] families = new String[] { "f1", "f2" }; final ProcedureExecutor procExec = getMasterProcedureExecutor(); @@ -80,7 +85,7 @@ public void testRecoverySnapshotRollback() throws Exception { // Wait for procedure to complete (should fail) ProcedureTestingUtility.waitProcedure(procExec, procId); Procedure result = procExec.getResult(procId); - assertTrue("Procedure should have failed", result.isFailed()); + assertTrue(result.isFailed(), "Procedure should have failed"); // Verify no recovery snapshots remain after rollback boolean snapshotFound = false; @@ -90,13 +95,13 @@ public void testRecoverySnapshotRollback() throws Exception { break; } } - assertTrue("Recovery snapshot should have been cleaned up during rollback", !snapshotFound); + assertTrue(!snapshotFound, "Recovery snapshot should have been cleaned up during rollback"); } @Test public void testRecoverySnapshotAndRestore() throws Exception { - final TableName tableName = TableName.valueOf(name.getMethodName()); - final TableName restoredTableName = TableName.valueOf(name.getMethodName() + "_restored"); + final TableName tableName = TableName.valueOf(testMethodName); + final TableName restoredTableName = TableName.valueOf(testMethodName + "_restored"); final String[] families = new String[] { "f1", "f2" }; // Create table with data @@ -127,7 +132,7 @@ public void testRecoverySnapshotAndRestore() throws Exception { break; } } - assertTrue("Recovery snapshot should exist", recoverySnapshotName != null); + assertTrue(recoverySnapshotName != null, "Recovery snapshot should exist"); // Restore from snapshot by cloning to a new table UTIL.getAdmin().cloneSnapshot(recoverySnapshotName, restoredTableName); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableWithMasterFailover.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableWithMasterFailover.java index e14075176169..244baf1ecd8f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableWithMasterFailover.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestTruncateTableWithMasterFailover.java @@ -17,9 +17,8 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; @@ -27,19 +26,15 @@ import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TruncateTableState; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestTruncateTableWithMasterFailover extends MasterFailoverWithProceduresTestBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestTruncateTableWithMasterFailover.class); - // ========================================================================== // Test Truncate Table // ========================================================================== diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestWALProcedureStoreOnHDFS.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestWALProcedureStoreOnHDFS.java index e4ae9f95a826..a03d2c713623 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestWALProcedureStoreOnHDFS.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestWALProcedureStoreOnHDFS.java @@ -17,14 +17,14 @@ */ package org.apache.hadoop.hbase.master.procedure; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.concurrent.atomic.AtomicInteger; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.log.HBaseMarkers; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; @@ -37,20 +37,16 @@ import org.apache.hadoop.hbase.util.Threads; import org.apache.hadoop.hdfs.MiniDFSCluster; import org.apache.hadoop.hdfs.server.datanode.DataNode; -import org.junit.Before; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category({ MasterTests.class, LargeTests.class }) +@Tag(MasterTests.TAG) +@Tag(LargeTests.TAG) public class TestWALProcedureStoreOnHDFS { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestWALProcedureStoreOnHDFS.class); - private static final Logger LOG = LoggerFactory.getLogger(TestWALProcedureStoreOnHDFS.class); protected static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); @@ -70,7 +66,7 @@ public void abortProcess() { } }; - @Before + @BeforeEach public void initConfig() { Configuration conf = UTIL.getConfiguration(); @@ -83,7 +79,7 @@ public void initConfig() { conf.setInt(WALProcedureStore.MAX_SYNC_FAILURE_ROLL_CONF_KEY, 10); } - // No @Before because some tests need to do additional config first + // No @BeforeEach because some tests need to do additional config first private void setupDFS() throws Exception { Configuration conf = UTIL.getConfiguration(); MiniDFSCluster dfs = UTIL.startMiniDFSCluster(3); @@ -96,7 +92,7 @@ private void setupDFS() throws Exception { store.recoverLease(); } - // No @After + // No @AfterEach @SuppressWarnings("JUnit4TearDownNotRun") public void tearDown() throws Exception { store.stop(false); @@ -109,7 +105,7 @@ public void tearDown() throws Exception { } } - @Test(expected = RuntimeException.class) + @Test public void testWalAbortOnLowReplication() throws Exception { setupDFS(); @@ -119,13 +115,15 @@ public void testWalAbortOnLowReplication() throws Exception { UTIL.getDFSCluster().stopDataNode(0); assertEquals(2, UTIL.getDFSCluster().getDataNodes().size()); - store.insert(new TestProcedure(1, -1), null); - for (long i = 2; store.isRunning(); ++i) { - assertEquals(2, UTIL.getDFSCluster().getDataNodes().size()); - store.insert(new TestProcedure(i, -1), null); - Thread.sleep(100); - } - assertFalse(store.isRunning()); + assertThrows(RuntimeException.class, () -> { + store.insert(new TestProcedure(1, -1), null); + for (long i = 2; store.isRunning(); ++i) { + assertEquals(2, UTIL.getDFSCluster().getDataNodes().size()); + store.insert(new TestProcedure(i, -1), null); + Thread.sleep(100); + } + assertFalse(store.isRunning()); + }); } @Test @@ -171,8 +169,8 @@ public void abortProcess() { } assertFalse(store.isRunning()); - assertTrue(reCount.toString(), - reCount.get() >= store.getNumThreads() && reCount.get() < thread.length); + assertTrue(reCount.get() >= store.getNumThreads() && reCount.get() < thread.length, + reCount.toString()); } @Test