diff --git a/hbase-backup/pom.xml b/hbase-backup/pom.xml index 7cac75f88d2b..3cb712c00d60 100644 --- a/hbase-backup/pom.xml +++ b/hbase-backup/pom.xml @@ -177,11 +177,6 @@ junit-jupiter-params test - - org.junit.vintage - junit-vintage-engine - test - diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/IncrementalBackupRestoreTestBase.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/IncrementalBackupRestoreTestBase.java index 3ad686514ff3..7279db159f96 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/IncrementalBackupRestoreTestBase.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/IncrementalBackupRestoreTestBase.java @@ -38,7 +38,6 @@ import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.HFileTestUtil; -import org.junit.jupiter.api.BeforeAll; import org.apache.hbase.thirdparty.com.google.common.base.Throwables; @@ -47,10 +46,8 @@ public class IncrementalBackupRestoreTestBase extends TestBackupBase { private static final byte[] BULKLOAD_START_KEY = new byte[] { 0x00 }; private static final byte[] BULKLOAD_END_KEY = new byte[] { Byte.MAX_VALUE }; - @BeforeAll - public static void setUp() throws Exception { + static { provider = "multiwal"; - TestBackupBase.setUp(); } protected void checkThrowsCFMismatch(IOException ex, List tables) { diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBase.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBase.java index 68366dcf688a..8280dfc75473 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBase.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBase.java @@ -66,9 +66,6 @@ import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.wal.AbstractFSWALProvider; import org.apache.hadoop.hbase.wal.WALFactory; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; @@ -120,7 +117,6 @@ public IncrementalTableBackupClientForTest(Connection conn, String backupId, } @BeforeEach - @Before public void ensurePreviousBackupTestsAreCleanedUp() throws Exception { // Every operation here may not be necessary for any given test, // some often being no-ops. the goal is to help ensure atomicity @@ -348,7 +344,6 @@ public static void setUpHelper() throws Exception { * @throws Exception if starting the mini cluster or setting up the tables fails */ @BeforeAll - @BeforeClass public static void setUp() throws Exception { TEST_UTIL = new HBaseTestingUtil(); conf1 = TEST_UTIL.getConfiguration(); @@ -366,7 +361,6 @@ private static void populateFromMasterConfig(Configuration masterConf, Configura } @AfterAll - @AfterClass public static void tearDown() throws Exception { try { SnapshotTestingUtils.deleteAllSnapshots(TEST_UTIL.getAdmin()); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBoundaryTests.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBoundaryTests.java index b56a15d3a4a8..b553b77ad248 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBoundaryTests.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupBoundaryTests.java @@ -17,26 +17,22 @@ */ package org.apache.hadoop.hbase.backup; +import static org.junit.jupiter.api.Assertions.assertThrows; + 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.testclassification.LargeTests; -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; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupBoundaryTests extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupBoundaryTests.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupBoundaryTests.class); /** @@ -66,33 +62,39 @@ public void testFullBackupMultipleEmpty() throws Exception { * Verify that full backup fails on a single table that does not exist. * @throws Exception if doing the full backup fails */ - @Test(expected = IOException.class) + @Test public void testFullBackupSingleDNE() throws Exception { - LOG.info("test full backup fails on a single table that does not exist"); - List tables = toList("tabledne"); - fullTableBackup(tables); + assertThrows(IOException.class, () -> { + LOG.info("test full backup fails on a single table that does not exist"); + List tables = toList("tabledne"); + fullTableBackup(tables); + }); } /** * Verify that full backup fails on multiple tables that do not exist. * @throws Exception if doing the full backup fails */ - @Test(expected = IOException.class) + @Test public void testFullBackupMultipleDNE() throws Exception { - LOG.info("test full backup fails on multiple tables that do not exist"); - List tables = toList("table1dne", "table2dne"); - fullTableBackup(tables); + assertThrows(IOException.class, () -> { + LOG.info("test full backup fails on multiple tables that do not exist"); + List tables = toList("table1dne", "table2dne"); + fullTableBackup(tables); + }); } /** * Verify that full backup fails on tableset containing real and fake tables. * @throws Exception if doing the full backup fails */ - @Test(expected = IOException.class) + @Test public void testFullBackupMixExistAndDNE() throws Exception { - LOG.info("create full backup fails on tableset containing real and fake table"); + assertThrows(IOException.class, () -> { + LOG.info("create full backup fails on tableset containing real and fake table"); - List tables = toList(table1.getNameAsString(), "tabledne"); - fullTableBackup(tables); + List tables = toList(table1.getNameAsString(), "tabledne"); + fullTableBackup(tables); + }); } } diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupCommandLineTool.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupCommandLineTool.java index 77bc9bdb9b2f..76d2b4a31706 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupCommandLineTool.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupCommandLineTool.java @@ -17,28 +17,22 @@ */ package org.apache.hadoop.hbase.backup; -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.ByteArrayOutputStream; import java.io.PrintStream; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.util.ToolRunner; -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; -@Category(SmallTests.class) +@Tag(SmallTests.TAG) public class TestBackupCommandLineTool { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupCommandLineTool.class); - private final static String USAGE_DESCRIBE = "Usage: hbase backup describe "; private final static String USAGE_CREATE = "Usage: hbase backup create"; private final static String USAGE_HISTORY = "Usage: hbase backup history"; @@ -50,7 +44,7 @@ public class TestBackupCommandLineTool { Configuration conf; - @Before + @BeforeEach public void setUpBefore() throws Exception { conf = HBaseConfiguration.create(); conf.setBoolean(BackupRestoreConstants.BACKUP_ENABLE_KEY, true); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDelete.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDelete.java index 785859c52805..40b179833a34 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDelete.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDelete.java @@ -17,38 +17,32 @@ */ package org.apache.hadoop.hbase.backup; -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.ByteArrayOutputStream; import java.io.PrintStream; import java.util.List; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.EnvironmentEdge; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.util.ToolRunner; -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; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; import org.apache.hbase.thirdparty.com.google.common.collect.Sets; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupDelete extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupDelete.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupDelete.class); /** @@ -138,7 +132,7 @@ public long currentTime() { assertTrue(ret == 0); } catch (Exception e) { LOG.error("failed", e); - Assert.fail(e.getMessage()); + fail(e.getMessage()); } String output = baos.toString(); LOG.info(baos.toString()); @@ -154,7 +148,7 @@ public long currentTime() { assertTrue(ret == 0); } catch (Exception e) { LOG.error("failed", e); - Assert.fail(e.getMessage()); + fail(e.getMessage()); } output = baos.toString(); LOG.info(baos.toString()); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteRestore.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteRestore.java index cdf8d608ccb0..00acb1afa929 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteRestore.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteRestore.java @@ -17,11 +17,10 @@ */ package org.apache.hadoop.hbase.backup; -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.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.util.BackupUtils; import org.apache.hadoop.hbase.client.Admin; @@ -29,21 +28,16 @@ import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.testclassification.LargeTests; 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.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupDeleteRestore extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupDeleteRestore.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupDeleteRestore.class); /** diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteWithFailures.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteWithFailures.java index 12c8d5c4065c..43655288a4fc 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteWithFailures.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDeleteWithFailures.java @@ -17,8 +17,8 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.ArrayList; @@ -26,7 +26,6 @@ import java.util.Optional; 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.HConstants; import org.apache.hadoop.hbase.TableName; @@ -42,10 +41,9 @@ import org.apache.hadoop.hbase.coprocessor.ObserverContext; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +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; @@ -56,13 +54,9 @@ * TestBackupSmallTests is where tests that don't require bring machines up/down should go All other * tests should have their own classes and extend this one */ -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupDeleteWithFailures extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupDeleteWithFailures.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupDeleteWithFailures.class); public enum Failure { @@ -117,7 +111,7 @@ public void postDeleteSnapshot(ObserverContext ctx * Setup Cluster with appropriate configurations before running tests. * @throws Exception if starting the mini cluster or setting up the tables fails */ - @BeforeClass + @BeforeAll public static void setUp() throws Exception { TEST_UTIL = new HBaseTestingUtil(); conf1 = TEST_UTIL.getConfiguration(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDescribe.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDescribe.java index 7ce039fd6668..03f7c9ca07dc 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDescribe.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupDescribe.java @@ -17,34 +17,28 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.ByteArrayOutputStream; import java.io.PrintStream; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.BackupInfo.BackupState; import org.apache.hadoop.hbase.backup.impl.BackupCommands; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupDescribe extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupDescribe.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupDescribe.class); /** diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupHFileCleaner.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupHFileCleaner.java index ef72b994c773..02c48e8e11fd 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupHFileCleaner.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupHFileCleaner.java @@ -17,8 +17,8 @@ */ package org.apache.hadoop.hbase.backup; -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; @@ -28,31 +28,26 @@ import org.apache.hadoop.fs.FileStatus; 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.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; 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; import org.apache.hbase.thirdparty.com.google.common.collect.Sets; -@Category({ MasterTests.class, MediumTests.class }) +@Tag(MasterTests.TAG) +@Tag(MediumTests.TAG) public class TestBackupHFileCleaner { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupHFileCleaner.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupHFileCleaner.class); private final static HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil(); private final static Configuration conf = TEST_UTIL.getConfiguration(); @@ -64,24 +59,24 @@ public class TestBackupHFileCleaner { private Path root; - @BeforeClass + @BeforeAll public static void setUpBeforeClass() throws Exception { conf.setBoolean(BackupRestoreConstants.BACKUP_ENABLE_KEY, true); TEST_UTIL.startMiniCluster(1); fs = FileSystem.get(conf); } - @AfterClass + @AfterAll public static void tearDownAfterClass() throws Exception { TEST_UTIL.shutdownMiniCluster(); } - @Before + @BeforeEach public void setup() throws IOException { root = TEST_UTIL.getDataTestDirOnTestFS(); } - @After + @AfterEach public void cleanup() { try { fs.delete(root, true); @@ -139,7 +134,7 @@ private Iterable callCleaner(BackupHFileCleaner cleaner, Iterable postRestoreBackupFiles = getBackupFiles(); // Check that the backup files are the same before and after the restore process - Assert.assertEquals(postRestoreBackupFiles, preRestoreBackupFiles); - Assert.assertEquals(TEST_UTIL.countRows(table1_restore), NB_ROWS_IN_BATCH); + assertEquals(postRestoreBackupFiles, preRestoreBackupFiles); + assertEquals(NB_ROWS_IN_BATCH, TEST_UTIL.countRows(table1_restore)); int ROWS_TO_ADD = 1_000; // different IDs so that rows don't overlap diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreOnEmptyEnvironment.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreOnEmptyEnvironment.java index 8a20f9750887..ee89aae91e33 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreOnEmptyEnvironment.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreOnEmptyEnvironment.java @@ -22,8 +22,8 @@ import static org.apache.hadoop.hbase.backup.BackupTestUtil.verifyBackup; import static org.apache.hadoop.hbase.backup.BackupType.FULL; import static org.apache.hadoop.hbase.backup.BackupType.INCREMENTAL; -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.Instant; @@ -31,12 +31,12 @@ import java.util.Arrays; import java.util.Collections; import java.util.List; +import java.util.stream.Stream; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.Cell; -import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.HBaseConfiguration; +import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupAdminImpl; import org.apache.hadoop.hbase.client.Admin; @@ -52,36 +52,33 @@ import org.apache.hadoop.hbase.testing.TestingHBaseCluster; import org.apache.hadoop.hbase.testing.TestingHBaseClusterOption; 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.Test; -import org.junit.experimental.categories.Category; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +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.TestTemplate; +import org.junit.jupiter.params.provider.Arguments; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category(LargeTests.class) -@RunWith(Parameterized.class) +@Tag(LargeTests.TAG) +@HBaseParameterizedTestTemplate(name = "{index}: restoreToOtherTable={0}") public class TestBackupRestoreOnEmptyEnvironment { private static final Logger LOG = LoggerFactory.getLogger(TestBackupRestoreOnEmptyEnvironment.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupRestoreOnEmptyEnvironment.class); + public boolean restoreToOtherTable; - @Parameterized.Parameters(name = "{index}: restoreToOtherTable={0}") - public static Iterable data() { - return HBaseCommonTestingUtil.BOOLEAN_PARAMETERIZED; + public TestBackupRestoreOnEmptyEnvironment(boolean restoreToOtherTable) { + this.restoreToOtherTable = restoreToOtherTable; + } + + public static Stream parameters() { + return Stream.of(Arguments.of(true), Arguments.of(false)); } - @Parameterized.Parameter(0) - public boolean restoreToOtherTable; private TableName sourceTable; private TableName targetTable; @@ -89,7 +86,7 @@ public static Iterable data() { private static Path BACKUP_ROOT_DIR; private static final byte[] COLUMN_FAMILY = Bytes.toBytes("0"); - @BeforeClass + @BeforeAll public static void beforeClass() throws Exception { Configuration conf = HBaseConfiguration.create(); enableBackup(conf); @@ -98,12 +95,12 @@ public static void beforeClass() throws Exception { BACKUP_ROOT_DIR = new Path(new Path(conf.get("fs.defaultFS")), new Path("/backupIT")); } - @AfterClass + @AfterAll public static void afterClass() throws Exception { cluster.stop(); } - @Before + @BeforeEach public void setUp() throws Exception { sourceTable = TableName.valueOf("table"); targetTable = TableName.valueOf("another-table"); @@ -111,12 +108,12 @@ public void setUp() throws Exception { createTable(targetTable); } - @After + @AfterEach public void removeTables() throws Exception { deleteTables(); } - @Test + @TestTemplate public void testRestoreToCorrectTable() throws Exception { Instant timestamp = Instant.now().minusSeconds(10); @@ -140,7 +137,7 @@ public void testRestoreToCorrectTable() throws Exception { } - @Test + @TestTemplate public void testRestoreCorrectTableForIncremental() throws Exception { Instant timestamp = Instant.now().minusSeconds(10); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreWithModifications.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreWithModifications.java index 04fcff930637..3b20d3624a5c 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreWithModifications.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupRestoreWithModifications.java @@ -21,9 +21,9 @@ import static org.apache.hadoop.hbase.backup.BackupTestUtil.enableBackup; import static org.apache.hadoop.hbase.backup.BackupTestUtil.verifyBackup; import static org.apache.hadoop.hbase.backup.BackupType.FULL; -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.nio.ByteBuffer; @@ -33,13 +33,13 @@ import java.util.List; import java.util.Map; import java.util.UUID; +import java.util.stream.Stream; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.Cell; -import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.HBaseConfiguration; +import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupAdminImpl; @@ -59,35 +59,31 @@ import org.apache.hadoop.hbase.testing.TestingHBaseClusterOption; import org.apache.hadoop.hbase.tool.BulkLoadHFiles; import org.apache.hadoop.hbase.util.Bytes; -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.runner.RunWith; -import org.junit.runners.Parameterized; +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.TestTemplate; +import org.junit.jupiter.params.provider.Arguments; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category(LargeTests.class) -@RunWith(Parameterized.class) +@Tag(LargeTests.TAG) +@HBaseParameterizedTestTemplate(name = "{index}: useBulkLoad={0}") public class TestBackupRestoreWithModifications { private static final Logger LOG = LoggerFactory.getLogger(TestBackupRestoreWithModifications.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupRestoreWithModifications.class); + public boolean useBulkLoad; - @Parameterized.Parameters(name = "{index}: useBulkLoad={0}") - public static Iterable data() { - return HBaseCommonTestingUtil.BOOLEAN_PARAMETERIZED; + public TestBackupRestoreWithModifications(boolean useBulkLoad) { + this.useBulkLoad = useBulkLoad; } - @Parameterized.Parameter(0) - public boolean useBulkLoad; + public static Stream parameters() { + return Stream.of(Arguments.of(true), Arguments.of(false)); + } private TableName sourceTable; private TableName targetTable; @@ -97,7 +93,7 @@ public static Iterable data() { private static final Path BACKUP_ROOT_DIR = new Path("backupIT"); private static final byte[] COLUMN_FAMILY = Bytes.toBytes("0"); - @BeforeClass + @BeforeAll public static void beforeClass() throws Exception { Configuration conf = HBaseConfiguration.create(); enableBackup(conf); @@ -105,12 +101,12 @@ public static void beforeClass() throws Exception { cluster.start(); } - @AfterClass + @AfterAll public static void afterClass() throws Exception { cluster.stop(); } - @Before + @BeforeEach public void setUp() throws Exception { sourceTable = TableName.valueOf("table-" + useBulkLoad); targetTable = TableName.valueOf("another-table-" + useBulkLoad); @@ -119,7 +115,7 @@ public void setUp() throws Exception { createTable(targetTable); } - @Test + @TestTemplate public void testModificationsOnTable() throws Exception { Instant timestamp = Instant.now(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupShowHistory.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupShowHistory.java index a3d5470a7e64..42c9bdb392eb 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupShowHistory.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupShowHistory.java @@ -17,30 +17,24 @@ */ package org.apache.hadoop.hbase.backup; -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.ByteArrayOutputStream; import java.io.PrintStream; import java.util.List; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.backup.util.BackupUtils; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupShowHistory extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupShowHistory.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupShowHistory.class); /** diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSmallTests.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSmallTests.java index 5add9412014f..361c3428282f 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSmallTests.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSmallTests.java @@ -17,25 +17,21 @@ */ package org.apache.hadoop.hbase.backup; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.io.IOException; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.fs.permission.FsPermission; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hdfs.DFSTestUtil; import org.apache.hadoop.security.UserGroupInformation; -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 TestBackupSmallTests extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupSmallTests.class); - private static final UserGroupInformation DIANA = UserGroupInformation.createUserForTesting("diana", new String[] {}); private static final String PERMISSION_TEST_PATH = Path.SEPARATOR + "permissionUT"; @@ -47,14 +43,16 @@ public void testBackupPathIsAccessible() throws Exception { fs.mkdirs(path); } - @Test(expected = IOException.class) + @Test public void testBackupPathIsNotAccessible() throws Exception { - Path path = new Path(PERMISSION_TEST_PATH); - FileSystem rootFs = FileSystem.get(TEST_UTIL.getConnection().getConfiguration()); - rootFs.mkdirs(path.getParent()); - rootFs.setPermission(path.getParent(), FsPermission.createImmutable((short) 000)); - FileSystem fs = - DFSTestUtil.getFileSystemAs(DIANA, TEST_UTIL.getConnection().getConfiguration()); - fs.mkdirs(path); + assertThrows(IOException.class, () -> { + Path path = new Path(PERMISSION_TEST_PATH); + FileSystem rootFs = FileSystem.get(TEST_UTIL.getConnection().getConfiguration()); + rootFs.mkdirs(path.getParent()); + rootFs.setPermission(path.getParent(), FsPermission.createImmutable((short) 000)); + FileSystem fs = + DFSTestUtil.getFileSystemAs(DIANA, TEST_UTIL.getConnection().getConfiguration()); + fs.mkdirs(path); + }); } } diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupStatusProgress.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupStatusProgress.java index 1a1e5dbf1cc1..ecf2915f8249 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupStatusProgress.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupStatusProgress.java @@ -17,31 +17,25 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.ByteArrayOutputStream; import java.io.PrintStream; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.BackupInfo.BackupState; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupStatusProgress extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupStatusProgress.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupStatusProgress.class); /** diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSystemTable.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSystemTable.java index 731f5f5b354f..26a04f1ddd8d 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSystemTable.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupSystemTable.java @@ -17,10 +17,10 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertEquals; -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.assertEquals; +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 java.util.ArrayList; @@ -34,7 +34,6 @@ import java.util.Set; import java.util.TreeSet; 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; @@ -45,31 +44,26 @@ import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; -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; /** * Test cases for backup system table API */ -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupSystemTable { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupSystemTable.class); - private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); protected static Configuration conf = UTIL.getConfiguration(); protected static SingleProcessHBaseCluster cluster; protected static Connection conn; protected BackupSystemTable table; - @BeforeClass + @BeforeAll public static void setUp() throws Exception { conf.setBoolean(BackupRestoreConstants.BACKUP_ENABLE_KEY, true); BackupManager.decorateMasterConfiguration(conf); @@ -78,12 +72,12 @@ public static void setUp() throws Exception { conn = UTIL.getConnection(); } - @Before + @BeforeEach public void before() throws IOException { table = new BackupSystemTable(conn); } - @After + @AfterEach public void after() { if (table != null) { table.close(); @@ -504,7 +498,7 @@ private List createBackupInfoList(int size) throws InterruptedExcept return list; } - @AfterClass + @AfterAll public static void tearDown() throws IOException { if (cluster != null) { cluster.shutdown(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupUtils.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupUtils.java index 3fc2c31a9d51..cf69476270c5 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupUtils.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestBackupUtils.java @@ -17,12 +17,15 @@ */ package org.apache.hadoop.hbase.backup; +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 java.io.IOException; import java.security.PrivilegedAction; 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.HConstants; import org.apache.hadoop.hbase.ServerName; @@ -33,18 +36,14 @@ import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.security.UserGroupInformation; -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; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category(SmallTests.class) +@Tag(SmallTests.TAG) public class TestBackupUtils { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupUtils.class); + private static final Logger LOG = LoggerFactory.getLogger(TestBackupUtils.class); protected static HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil(); @@ -82,7 +81,7 @@ public Path run() { } }); // Make sure the directory is in foo1234's home directory - Assert.assertTrue(bulkOutputDir.toString().startsWith(fooHomeDirectory.toString())); + assertTrue(bulkOutputDir.toString().startsWith(fooHomeDirectory.toString())); } @Test @@ -99,18 +98,18 @@ public void testFilesystemWalHostNameParsing() throws IOException { Path testOldWalPath = new Path(oldLogDir, serverName + BackupUtils.LOGNAME_SEPARATOR + EnvironmentEdgeManager.currentTime()); - Assert.assertEquals(host + Addressing.HOSTNAME_PORT_SEPARATOR + port, + assertEquals(host + Addressing.HOSTNAME_PORT_SEPARATOR + port, BackupUtils.parseHostFromOldLog(testOldWalPath)); Path testMasterWalPath = new Path(oldLogDir, testOldWalPath.getName() + MasterRegionFactory.ARCHIVED_WAL_SUFFIX); - Assert.assertNull(BackupUtils.parseHostFromOldLog(testMasterWalPath)); + assertNull(BackupUtils.parseHostFromOldLog(testMasterWalPath)); // org.apache.hadoop.hbase.wal.BoundedGroupingStrategy does this Path testOldWalWithRegionGroupingPath = new Path(oldLogDir, serverName + BackupUtils.LOGNAME_SEPARATOR + serverName + BackupUtils.LOGNAME_SEPARATOR + "regiongroup-0" + BackupUtils.LOGNAME_SEPARATOR + EnvironmentEdgeManager.currentTime()); - Assert.assertEquals(host + Addressing.HOSTNAME_PORT_SEPARATOR + port, + assertEquals(host + Addressing.HOSTNAME_PORT_SEPARATOR + port, BackupUtils.parseHostFromOldLog(testOldWalWithRegionGroupingPath)); } diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackup.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackup.java index ba09817fcdec..ca0c0338ba75 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackup.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackup.java @@ -17,32 +17,26 @@ */ package org.apache.hadoop.hbase.backup; -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.HashSet; import java.util.List; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.backup.impl.BackupManifest; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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; import org.apache.hbase.thirdparty.com.google.common.collect.Sets; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestFullBackup extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFullBackup.class); - private static final Logger LOG = LoggerFactory.getLogger(TestFullBackup.class); @Test diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSet.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSet.java index af6ce077e051..6a598f40d7a9 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSet.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSet.java @@ -17,30 +17,24 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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(LargeTests.class) +@Tag(LargeTests.TAG) public class TestFullBackupSet extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFullBackupSet.class); - private static final Logger LOG = LoggerFactory.getLogger(TestFullBackupSet.class); /** diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSetRestoreSet.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSetRestoreSet.java index 98e05cc5a128..b248bd8c1232 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSetRestoreSet.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupSetRestoreSet.java @@ -17,30 +17,24 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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(LargeTests.class) +@Tag(LargeTests.TAG) public class TestFullBackupSetRestoreSet extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFullBackupSetRestoreSet.class); - private static final Logger LOG = LoggerFactory.getLogger(TestFullBackupSetRestoreSet.class); @Test @@ -55,15 +49,15 @@ public void testFullRestoreSetToOtherTable() throws Exception { List names = table.describeBackupSet(name); assertNotNull(names); - assertTrue(names.size() == 1); + assertEquals(1, names.size()); assertTrue(names.get(0).equals(table1)); String[] args = new String[] { "create", "full", BACKUP_ROOT_DIR, "-s", name }; // Run backup int ret = ToolRunner.run(conf1, new BackupDriver(), args); - assertTrue(ret == 0); + assertEquals(0, ret); List backups = table.getBackupHistory(); - assertTrue(backups.size() == 1); + assertEquals(1, backups.size()); String backupId = backups.get(0).getBackupId(); assertTrue(checkSucceeded(backupId)); @@ -74,7 +68,7 @@ public void testFullRestoreSetToOtherTable() throws Exception { table1_restore.getNameAsString(), "-o" }; // Run backup ret = ToolRunner.run(conf1, new RestoreDriver(), args); - assertTrue(ret == 0); + assertEquals(0, ret); Admin hba = TEST_UTIL.getAdmin(); assertTrue(hba.tableExists(table1_restore)); // Verify number of rows in both tables @@ -97,13 +91,13 @@ public void testFullRestoreSetToSameTable() throws Exception { List names = table.describeBackupSet(name); assertNotNull(names); - assertTrue(names.size() == 1); + assertEquals(1, names.size()); assertTrue(names.get(0).equals(table1)); String[] args = new String[] { "create", "full", BACKUP_ROOT_DIR, "-s", name }; // Run backup int ret = ToolRunner.run(conf1, new BackupDriver(), args); - assertTrue(ret == 0); + assertEquals(0, ret); List backups = table.getBackupHistory(); String backupId = backups.get(0).getBackupId(); assertTrue(checkSucceeded(backupId)); @@ -116,7 +110,7 @@ public void testFullRestoreSetToSameTable() throws Exception { args = new String[] { BACKUP_ROOT_DIR, backupId, "-s", name, "-o" }; // Run backup ret = ToolRunner.run(conf1, new RestoreDriver(), args); - assertTrue(ret == 0); + assertEquals(0, ret); Admin hba = TEST_UTIL.getAdmin(); assertTrue(hba.tableExists(table1)); // Verify number of rows in both tables diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupWithFailures.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupWithFailures.java index 1536fd1841fb..6ffd09644c26 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupWithFailures.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullBackupWithFailures.java @@ -17,31 +17,25 @@ */ package org.apache.hadoop.hbase.backup; -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.Set; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.backup.impl.TableBackupClient; import org.apache.hadoop.hbase.backup.impl.TableBackupClient.Stage; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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(LargeTests.class) +@Tag(LargeTests.TAG) public class TestFullBackupWithFailures extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFullBackupWithFailures.class); - private static final Logger LOG = LoggerFactory.getLogger(TestFullBackupWithFailures.class); @Test @@ -75,7 +69,7 @@ public void runBackupAndFailAtStage(int stage) throws Exception { assertFalse(checkSucceeded(backupId)); } Set tables = table.getIncrementalBackupTableSet(BACKUP_ROOT_DIR); - assertTrue(tables.size() == 0); + assertTrue(tables.isEmpty()); } } diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullRestore.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullRestore.java index d16d7af75014..1eb26a9b82aa 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullRestore.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestFullRestore.java @@ -17,34 +17,29 @@ */ package org.apache.hadoop.hbase.backup; -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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.IOException; import java.util.List; import org.apache.commons.lang3.StringUtils; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.util.BackupUtils; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestFullRestore extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestFullRestore.class); - private static final Logger LOG = LoggerFactory.getLogger(TestFullRestore.class); /** @@ -293,20 +288,22 @@ public void testFullRestoreMultipleOverwriteCommand() throws Exception { * Verify that restore fails on a single table that does not exist. * @throws Exception if doing the backup or restoring it fails */ - @Test(expected = IOException.class) + @Test public void testFullRestoreSingleDNE() throws Exception { - LOG.info("test restore fails on a single table that does not exist"); - List tables = Lists.newArrayList(table1); - String backupId = fullTableBackup(tables); - assertTrue(checkSucceeded(backupId)); - - LOG.info("backup complete"); - - TableName[] tableset = new TableName[] { TableName.valueOf("faketable") }; - TableName[] tablemap = new TableName[] { table1_restore }; - BackupAdmin client = getBackupAdmin(); - client.restore(BackupUtils.createRestoreRequest(BACKUP_ROOT_DIR, backupId, false, tableset, - tablemap, false)); + assertThrows(IOException.class, () -> { + LOG.info("test restore fails on a single table that does not exist"); + List tables = Lists.newArrayList(table1); + String backupId = fullTableBackup(tables); + assertTrue(checkSucceeded(backupId)); + + LOG.info("backup complete"); + + TableName[] tableset = new TableName[] { TableName.valueOf("faketable") }; + TableName[] tablemap = new TableName[] { table1_restore }; + BackupAdmin client = getBackupAdmin(); + client.restore(BackupUtils.createRestoreRequest(BACKUP_ROOT_DIR, backupId, false, tableset, + tablemap, false)); + }); } /** @@ -335,20 +332,22 @@ public void testFullRestoreSingleDNECommand() throws Exception { * Verify that restore fails on multiple tables that do not exist. * @throws Exception if doing the backup or restoring it fails */ - @Test(expected = IOException.class) + @Test public void testFullRestoreMultipleDNE() throws Exception { - LOG.info("test restore fails on multiple tables that do not exist"); - - List tables = Lists.newArrayList(table2, table3); - String backupId = fullTableBackup(tables); - assertTrue(checkSucceeded(backupId)); - - TableName[] restore_tableset = - new TableName[] { TableName.valueOf("faketable1"), TableName.valueOf("faketable2") }; - TableName[] tablemap = new TableName[] { table2_restore, table3_restore }; - BackupAdmin client = getBackupAdmin(); - client.restore(BackupUtils.createRestoreRequest(BACKUP_ROOT_DIR, backupId, false, - restore_tableset, tablemap, false)); + assertThrows(IOException.class, () -> { + LOG.info("test restore fails on multiple tables that do not exist"); + + List tables = Lists.newArrayList(table2, table3); + String backupId = fullTableBackup(tables); + assertTrue(checkSucceeded(backupId)); + + TableName[] restore_tableset = + new TableName[] { TableName.valueOf("faketable1"), TableName.valueOf("faketable2") }; + TableName[] tablemap = new TableName[] { table2_restore, table3_restore }; + BackupAdmin client = getBackupAdmin(); + client.restore(BackupUtils.createRestoreRequest(BACKUP_ROOT_DIR, backupId, false, + restore_tableset, tablemap, false)); + }); } /** diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestHBackupFileSystem.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestHBackupFileSystem.java index 3bdc2f620794..4939f12eb55d 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestHBackupFileSystem.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestHBackupFileSystem.java @@ -17,24 +17,18 @@ */ package org.apache.hadoop.hbase.backup; -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.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(SmallTests.class) +@Tag(SmallTests.TAG) public class TestHBackupFileSystem { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestHBackupFileSystem.class); - private static final Path ROOT_DIR = new Path("/backup/root"); private static final String BACKUP_ID = "123"; diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupDeleteTable.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupDeleteTable.java index a5eec87fb06b..5bd69f57a821 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupDeleteTable.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupDeleteTable.java @@ -17,10 +17,10 @@ */ package org.apache.hadoop.hbase.backup; -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.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupAdminImpl; import org.apache.hadoop.hbase.backup.util.BackupUtils; @@ -31,10 +31,8 @@ import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.Bytes; -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; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -44,13 +42,9 @@ * 1. Create table t1, t2 2. Load data to t1, t2 3 Full backup t1, t2 4 Delete t2 5 Load data to t1 * 6 Incremental backup t1 */ -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestIncrementalBackupDeleteTable extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestIncrementalBackupDeleteTable.class); - private static final Logger LOG = LoggerFactory.getLogger(TestIncrementalBackupDeleteTable.class); // implement all test cases in 1 test since incremental backup/restore has dependencies @@ -78,7 +72,7 @@ public void testIncBackupDeleteTable() throws Exception { t1.put(p1); } - Assert.assertEquals(TEST_UTIL.countRows(t1), NB_ROWS_IN_BATCH * 2); + assertEquals(TEST_UTIL.countRows(t1), NB_ROWS_IN_BATCH * 2); t1.close(); // Delete table table2 @@ -106,11 +100,11 @@ public void testIncBackupDeleteTable() throws Exception { // #5.2 - checking row count of tables for full restore Table hTable = conn.getTable(table1_restore); - Assert.assertEquals(TEST_UTIL.countRows(hTable), NB_ROWS_IN_BATCH); + assertEquals(TEST_UTIL.countRows(hTable), NB_ROWS_IN_BATCH); hTable.close(); hTable = conn.getTable(table2_restore); - Assert.assertEquals(TEST_UTIL.countRows(hTable), NB_ROWS_IN_BATCH); + assertEquals(TEST_UTIL.countRows(hTable), NB_ROWS_IN_BATCH); hTable.close(); // #6 - restore incremental backup for table1 @@ -120,7 +114,7 @@ public void testIncBackupDeleteTable() throws Exception { tablesRestoreIncMultiple, tablesMapIncMultiple, true)); hTable = conn.getTable(table1_restore); - Assert.assertEquals(TEST_UTIL.countRows(hTable), NB_ROWS_IN_BATCH * 2); + assertEquals(TEST_UTIL.countRows(hTable), NB_ROWS_IN_BATCH * 2); hTable.close(); admin.close(); conn.close(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithBulkLoad.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithBulkLoad.java index 328364a85cee..4d4076f28c05 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithBulkLoad.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithBulkLoad.java @@ -34,13 +34,13 @@ import java.util.List; import java.util.Map; import java.util.UUID; +import java.util.stream.Stream; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.Cell; -import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseCommonTestingUtil; import org.apache.hadoop.hbase.HBaseConfiguration; +import org.apache.hadoop.hbase.HBaseParameterizedTestTemplate; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupAdminImpl; @@ -60,35 +60,31 @@ import org.apache.hadoop.hbase.testing.TestingHBaseClusterOption; import org.apache.hadoop.hbase.tool.BulkLoadHFiles; import org.apache.hadoop.hbase.util.Bytes; -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.runner.RunWith; -import org.junit.runners.Parameterized; +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.TestTemplate; +import org.junit.jupiter.params.provider.Arguments; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category(LargeTests.class) -@RunWith(Parameterized.class) +@Tag(LargeTests.TAG) +@HBaseParameterizedTestTemplate(name = "{index}: useBulkLoad={0}") public class TestIncrementalBackupMergeWithBulkLoad { private static final Logger LOG = LoggerFactory.getLogger(TestIncrementalBackupMergeWithBulkLoad.class); - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestIncrementalBackupMergeWithBulkLoad.class); + public boolean useBulkLoad; - @Parameterized.Parameters(name = "{index}: useBulkLoad={0}") - public static Iterable data() { - return HBaseCommonTestingUtil.BOOLEAN_PARAMETERIZED; + public TestIncrementalBackupMergeWithBulkLoad(boolean useBulkLoad) { + this.useBulkLoad = useBulkLoad; } - @Parameterized.Parameter(0) - public boolean useBulkLoad; + public static Stream parameters() { + return Stream.of(Arguments.of(true), Arguments.of(false)); + } private TableName sourceTable; private TableName targetTable; @@ -98,7 +94,7 @@ public static Iterable data() { private static final Path BACKUP_ROOT_DIR = new Path("backupIT"); private static final byte[] COLUMN_FAMILY = Bytes.toBytes("0"); - @BeforeClass + @BeforeAll public static void beforeClass() throws Exception { Configuration conf = HBaseConfiguration.create(); enableBackup(conf); @@ -106,12 +102,12 @@ public static void beforeClass() throws Exception { cluster.start(); } - @AfterClass + @AfterAll public static void afterClass() throws Exception { cluster.stop(); } - @Before + @BeforeEach public void setUp() throws Exception { sourceTable = TableName.valueOf("table-" + useBulkLoad); targetTable = TableName.valueOf("another-table-" + useBulkLoad); @@ -120,7 +116,7 @@ public void setUp() throws Exception { createTable(targetTable); } - @Test + @TestTemplate public void testMergeContainingBulkloadedHfiles() throws Exception { Instant timestamp = Instant.now(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithFailures.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithFailures.java index 1ece1770489b..ca066d436c2f 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithFailures.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupMergeWithFailures.java @@ -18,8 +18,8 @@ package org.apache.hadoop.hbase.backup; import static org.apache.hadoop.hbase.backup.util.BackupUtils.succeeded; -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.io.IOException; import java.util.ArrayList; @@ -28,7 +28,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.TableName; import org.apache.hadoop.hbase.backup.impl.BackupAdminImpl; import org.apache.hadoop.hbase.backup.impl.BackupCommands; @@ -42,22 +41,17 @@ import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.Pair; -import org.junit.Assert; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestIncrementalBackupMergeWithFailures extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestIncrementalBackupMergeWithFailures.class); - private static final Logger LOG = LoggerFactory.getLogger(TestIncrementalBackupMergeWithFailures.class); @@ -80,7 +74,7 @@ public void setConf(Configuration conf) { if (val != null) { failurePhase = FailurePhase.valueOf(val); } else { - Assert.fail("Failure phase is not set"); + Assertions.fail("Failure phase is not set"); } } @@ -248,13 +242,13 @@ public void TestIncBackupMergeRestore() throws Exception { Table t1 = insertIntoTable(conn, table1, famName, 1, ADD_ROWS); LOG.debug("writing " + ADD_ROWS + " rows to " + table1); - Assert.assertEquals(TEST_UTIL.countRows(t1), NB_ROWS_IN_BATCH + ADD_ROWS); + Assertions.assertEquals(NB_ROWS_IN_BATCH + ADD_ROWS, TEST_UTIL.countRows(t1)); t1.close(); LOG.debug("written " + ADD_ROWS + " rows to " + table1); Table t2 = insertIntoTable(conn, table2, famName, 1, ADD_ROWS); - Assert.assertEquals(TEST_UTIL.countRows(t2), NB_ROWS_IN_BATCH + ADD_ROWS); + Assertions.assertEquals(NB_ROWS_IN_BATCH + ADD_ROWS, TEST_UTIL.countRows(t2)); t2.close(); LOG.debug("written " + ADD_ROWS + " rows to " + table2); @@ -285,7 +279,7 @@ public void TestIncBackupMergeRestore() throws Exception { try (BackupAdmin bAdmin = new BackupAdminImpl(conn)) { String[] backups = new String[] { backupIdIncMultiple, backupIdIncMultiple2 }; bAdmin.mergeBackups(backups); - Assert.fail("Expected IOException"); + Assertions.fail("Expected IOException"); } catch (IOException e) { BackupSystemTable table = new BackupSystemTable(conn); if (phase.ordinal() < FailurePhase.PHASE4.ordinal()) { @@ -294,7 +288,7 @@ public void TestIncBackupMergeRestore() throws Exception { assertFalse(table.isMergeInProgress()); try { table.finishBackupExclusiveOperation(); - Assert.fail("IOException is expected"); + Assertions.fail("IOException is expected"); } catch (IOException ee) { // Expected } @@ -303,7 +297,7 @@ public void TestIncBackupMergeRestore() throws Exception { assertTrue(table.isMergeInProgress()); try { table.startBackupExclusiveOperation(); - Assert.fail("IOException is expected"); + Assertions.fail("IOException is expected"); } catch (IOException ee) { // Expected - clean up before proceeding // table.finishMergeOperation(); @@ -336,12 +330,12 @@ public void TestIncBackupMergeRestore() throws Exception { Table hTable = conn.getTable(table1_restore); LOG.debug("After incremental restore: " + hTable.getDescriptor()); LOG.debug("f1 has " + TEST_UTIL.countRows(hTable, famName) + " rows"); - Assert.assertEquals(TEST_UTIL.countRows(hTable, famName), NB_ROWS_IN_BATCH + 2 * ADD_ROWS); + Assertions.assertEquals(NB_ROWS_IN_BATCH + 2 * ADD_ROWS, TEST_UTIL.countRows(hTable, famName)); hTable.close(); hTable = conn.getTable(table2_restore); - Assert.assertEquals(TEST_UTIL.countRows(hTable), NB_ROWS_IN_BATCH + 2 * ADD_ROWS); + Assertions.assertEquals(NB_ROWS_IN_BATCH + 2 * ADD_ROWS, TEST_UTIL.countRows(hTable)); hTable.close(); admin.close(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestore.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestore.java index b692f3178907..e3c0a550829b 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestore.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestore.java @@ -90,14 +90,14 @@ public void testIncBackupRestore() throws Exception { // #2 - insert some data to table Table t1 = insertIntoTable(conn, table1, famName, 1, ADD_ROWS); LOG.debug("writing {} rows to {}", ADD_ROWS, table1); - assertEquals(HBaseTestingUtil.countRows(t1), NB_ROWS_IN_BATCH + ADD_ROWS + NB_ROWS_FAM3); + assertEquals(NB_ROWS_IN_BATCH + ADD_ROWS + NB_ROWS_FAM3, HBaseTestingUtil.countRows(t1)); LOG.debug("written {} rows to {}", ADD_ROWS, table1); // additionally, insert rows to MOB cf int NB_ROWS_MOB = 111; insertIntoTable(conn, table1, mobName, 3, NB_ROWS_MOB); LOG.debug("written {} rows to {} to Mob enabled CF", NB_ROWS_MOB, table1); t1.close(); - assertEquals(HBaseTestingUtil.countRows(t1), NB_ROWS_IN_BATCH + ADD_ROWS + NB_ROWS_MOB); + assertEquals(NB_ROWS_IN_BATCH + ADD_ROWS + NB_ROWS_MOB, HBaseTestingUtil.countRows(t1)); Table t2 = conn.getTable(table2); Put p2; for (int i = 0; i < 5; i++) { @@ -178,7 +178,7 @@ public void testIncBackupRestore() throws Exception { // #6.2 - checking row count of tables for full restore try (Table hTable = conn.getTable(table1_restore)) { - assertEquals(HBaseTestingUtil.countRows(hTable), NB_ROWS_IN_BATCH + NB_ROWS_FAM3); + assertEquals(NB_ROWS_IN_BATCH + NB_ROWS_FAM3, HBaseTestingUtil.countRows(hTable)); } try (Table hTable = conn.getTable(table2_restore)) { @@ -194,15 +194,15 @@ public void testIncBackupRestore() throws Exception { LOG.debug("After incremental restore: {}", hTable.getDescriptor()); int countFamName = HBaseTestingUtil.countRows(hTable, famName); LOG.debug("f1 has " + countFamName + " rows"); - assertEquals(countFamName, NB_ROWS_IN_BATCH + ADD_ROWS); + assertEquals(NB_ROWS_IN_BATCH + ADD_ROWS, countFamName); int countFam2Name = HBaseTestingUtil.countRows(hTable, fam2Name); LOG.debug("f2 has {} rows", countFam2Name); - assertEquals(countFam2Name, NB_ROWS_FAM2); + assertEquals(NB_ROWS_FAM2, countFam2Name); int countMobName = HBaseTestingUtil.countRows(hTable, mobName); LOG.debug("mob has {} rows", countMobName); - assertEquals(countMobName, NB_ROWS_MOB); + assertEquals(NB_ROWS_MOB, countMobName); } try (Table hTable = conn.getTable(table2_restore)) { diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestoreWithOriginalSplits.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestoreWithOriginalSplits.java index 8bece20839cb..68ea52da462e 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestoreWithOriginalSplits.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupRestoreWithOriginalSplits.java @@ -69,7 +69,7 @@ public void testIncBackupRestoreWithOriginalSplits() throws Exception { // Check that the backup files are the same before and after the restore process assertEquals(postRestoreBackupFiles, preRestoreBackupFiles); - assertEquals(TEST_UTIL.countRows(table1_restore), NB_ROWS_IN_BATCH); + assertEquals(NB_ROWS_IN_BATCH, TEST_UTIL.countRows(table1_restore)); int ROWS_TO_ADD = 1_000; // different IDs so that rows don't overlap diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithBulkLoad.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithBulkLoad.java index 73c26dce7353..481f8d755e75 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithBulkLoad.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithBulkLoad.java @@ -17,10 +17,10 @@ */ package org.apache.hadoop.hbase.backup; -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.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import java.io.IOException; import java.nio.ByteBuffer; @@ -29,7 +29,6 @@ import java.util.Map; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.backup.impl.BulkLoad; @@ -43,20 +42,15 @@ import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.HFileArchiveUtil; import org.apache.hadoop.hbase.util.HFileTestUtil; -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; /** * This test checks whether backups properly track & manage bulk files loads. */ -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestIncrementalBackupWithBulkLoad extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestIncrementalBackupWithBulkLoad.class); - private static final String TEST_NAME = TestIncrementalBackupWithBulkLoad.class.getSimpleName(); private static final int ROWS_IN_BULK_LOAD = 100; @@ -182,7 +176,7 @@ public void testUpdateFileListsRaceCondition() throws Exception { regionName, columnFamily); Path archivedFile1 = new Path(archiveDir, filename1); fs.mkdirs(archiveDir); - assertTrue("File should be moved to archive", fs.rename(activeFile1, archivedFile1)); + assertTrue(fs.rename(activeFile1, archivedFile1), "File should be moved to archive"); TestBackupBase.IncrementalTableBackupClientForTest client = new TestBackupBase.IncrementalTableBackupClientForTest(TEST_UTIL.getConnection(), @@ -191,12 +185,12 @@ public void testUpdateFileListsRaceCondition() throws Exception { client.updateFileLists(activeFiles, archiveFiles); - assertEquals("Only one file should remain in active files", 1, activeFiles.size()); - assertEquals("File2 should still be in active files", activeFile2.toString(), - activeFiles.get(0)); - assertEquals("One file should be added to archive files", 1, archiveFiles.size()); - assertEquals("Archived file should have correct path", archivedFile1.toString(), - archiveFiles.get(0)); + assertEquals(1, activeFiles.size(), "Only one file should remain in active files"); + assertEquals(activeFile2.toString(), activeFiles.get(0), + "File2 should still be in active files"); + assertEquals(1, archiveFiles.size(), "One file should be added to archive files"); + assertEquals(archivedFile1.toString(), archiveFiles.get(0), + "Archived file should have correct path"); systemTable.finishBackupExclusiveOperation(); } diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithDataLoss.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithDataLoss.java index cf442f5f0dd7..efbe7cbe46a1 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithDataLoss.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithDataLoss.java @@ -17,31 +17,25 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupAdminImpl; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.testclassification.LargeTests; -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; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestIncrementalBackupWithDataLoss extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestIncrementalBackupWithDataLoss.class); - private static final Logger LOG = LoggerFactory.getLogger(TestIncrementalBackupWithDataLoss.class); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithFailures.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithFailures.java index c8d536564188..b1dec43fef54 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithFailures.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackupWithFailures.java @@ -17,13 +17,11 @@ */ package org.apache.hadoop.hbase.backup; -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.Collection; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.BackupInfo.BackupState; import org.apache.hadoop.hbase.backup.impl.BackupAdminImpl; @@ -41,37 +39,21 @@ import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.util.ToolRunner; -import org.junit.Assert; -import org.junit.ClassRule; -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.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) -@RunWith(Parameterized.class) +@Tag(LargeTests.TAG) public class TestIncrementalBackupWithFailures extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestIncrementalBackupWithFailures.class); - private static final Logger LOG = LoggerFactory.getLogger(TestIncrementalBackupWithFailures.class); - @Parameterized.Parameters - public static Collection data() { + static { provider = "multiwal"; - List params = new ArrayList(); - params.add(new Object[] { Boolean.TRUE }); - return params; - } - - public TestIncrementalBackupWithFailures(Boolean b) { } // implement all test cases in 1 test since incremental backup/restore has dependencies @@ -103,7 +85,7 @@ public void testIncBackupRestore() throws Exception { Table t1 = insertIntoTable(conn, table1, famName, 1, ADD_ROWS); LOG.debug("writing " + ADD_ROWS + " rows to " + table1); - Assert.assertEquals(TEST_UTIL.countRows(t1), NB_ROWS_IN_BATCH + ADD_ROWS + NB_ROWS_FAM3); + assertEquals(TEST_UTIL.countRows(t1), NB_ROWS_IN_BATCH + ADD_ROWS + NB_ROWS_FAM3); t1.close(); LOG.debug("written " + ADD_ROWS + " rows to " + table1); @@ -115,7 +97,7 @@ public void testIncBackupRestore() throws Exception { t2.put(p2); } - Assert.assertEquals(TEST_UTIL.countRows(t2), NB_ROWS_IN_BATCH + 5); + assertEquals(TEST_UTIL.countRows(t2), NB_ROWS_IN_BATCH + 5); t2.close(); LOG.debug("written " + 5 + " rows to " + table2); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteBackup.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteBackup.java index a148ab232dc2..f56095cb7d11 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteBackup.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteBackup.java @@ -17,11 +17,11 @@ */ package org.apache.hadoop.hbase.backup; -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.concurrent.CountDownLatch; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtil; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; @@ -38,30 +38,24 @@ import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.Bytes; -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.BeforeAll; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestRemoteBackup extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRemoteBackup.class); - private static final Logger LOG = LoggerFactory.getLogger(TestRemoteBackup.class); /** * Setup Cluster with appropriate configurations before running tests. * @throws Exception if starting the mini cluster or setting up the tables fails */ - @BeforeClass + @BeforeAll public static void setUp() throws Exception { TEST_UTIL = new HBaseTestingUtil(); conf1 = TEST_UTIL.getConfiguration(); @@ -120,10 +114,10 @@ public void testFullBackupRemote() throws Exception { assertTrue(checkSucceeded(backupId)); LOG.info("backup complete " + backupId); - Assert.assertEquals(TEST_UTIL.countRows(t1, famName), NB_ROWS_IN_BATCH); + assertEquals(NB_ROWS_IN_BATCH, TEST_UTIL.countRows(t1, famName)); t.join(); - Assert.assertEquals(TEST_UTIL.countRows(t1, fam3Name), NB_ROWS_IN_FAM3); + assertEquals(NB_ROWS_IN_FAM3, TEST_UTIL.countRows(t1, fam3Name)); t1.close(); TableName[] tablesRestoreFull = new TableName[] { table1 }; @@ -140,12 +134,12 @@ public void testFullBackupRemote() throws Exception { // #5.2 - checking row count of tables for full restore Table hTable = conn.getTable(table1_restore); - Assert.assertEquals(TEST_UTIL.countRows(hTable, famName), NB_ROWS_IN_BATCH); + assertEquals(NB_ROWS_IN_BATCH, TEST_UTIL.countRows(hTable, famName)); int cnt3 = TEST_UTIL.countRows(hTable, fam3Name); - Assert.assertTrue(cnt3 >= 0 && cnt3 <= NB_ROWS_IN_FAM3); + assertTrue(cnt3 >= 0 && cnt3 <= NB_ROWS_IN_FAM3); int rows1 = MobSnapshotTestingUtils.countMobRows(t1, fam2Name); - Assert.assertEquals(rows0, rows1); + assertEquals(rows0, rows1); hTable.close(); hAdmin.close(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteRestore.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteRestore.java index bdd07b37666c..475bb2e1933a 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteRestore.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRemoteRestore.java @@ -17,13 +17,12 @@ */ package org.apache.hadoop.hbase.backup; -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 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.HConstants; import org.apache.hadoop.hbase.TableName; @@ -33,27 +32,22 @@ import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.testclassification.LargeTests; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +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(LargeTests.class) +@Tag(LargeTests.TAG) public class TestRemoteRestore extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRemoteRestore.class); - private static final Logger LOG = LoggerFactory.getLogger(TestRemoteRestore.class); /** * Setup Cluster with appropriate configurations before running tests. * @throws Exception if starting the mini cluster or setting up the tables fails */ - @BeforeClass + @BeforeAll public static void setUp() throws Exception { TEST_UTIL = new HBaseTestingUtil(); conf1 = TEST_UTIL.getConfiguration(); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRepairAfterFailedDelete.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRepairAfterFailedDelete.java index 93345fd17059..a134c974fee6 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRepairAfterFailedDelete.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRepairAfterFailedDelete.java @@ -17,33 +17,27 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.util.ToolRunner; -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; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestRepairAfterFailedDelete extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRepairAfterFailedDelete.class); - private static final Logger LOG = LoggerFactory.getLogger(TestRepairAfterFailedDelete.class); @Test diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRestoreBoundaryTests.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRestoreBoundaryTests.java index 7b49558031e8..d935dd6ff6ab 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRestoreBoundaryTests.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestRestoreBoundaryTests.java @@ -17,27 +17,21 @@ */ package org.apache.hadoop.hbase.backup; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.List; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.util.BackupUtils; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.testclassification.LargeTests; -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(LargeTests.class) +@Tag(LargeTests.TAG) public class TestRestoreBoundaryTests extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRestoreBoundaryTests.class); - private static final Logger LOG = LoggerFactory.getLogger(TestRestoreBoundaryTests.class); /** diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestSystemTableSnapshot.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestSystemTableSnapshot.java index f626dec5875d..40e078f5b576 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestSystemTableSnapshot.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/TestSystemTableSnapshot.java @@ -17,30 +17,27 @@ */ package org.apache.hadoop.hbase.backup; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.backup.impl.BackupSystemTable; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.testclassification.LargeTests; -import org.junit.ClassRule; -import org.junit.experimental.categories.Category; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Category(LargeTests.class) +@Tag(LargeTests.TAG) public class TestSystemTableSnapshot extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestSystemTableSnapshot.class); - private static final Logger LOG = LoggerFactory.getLogger(TestSystemTableSnapshot.class); /** * Verify backup system table snapshot. * @throws Exception if an operation on the table fails */ - // @Test + @Disabled + @Test public void _testBackupRestoreSystemTable() throws Exception { LOG.info("test snapshot system table"); diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/mapreduce/TestMapReduceBackupCopyJob.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/mapreduce/TestMapReduceBackupCopyJob.java index 6e35815c84f8..ee1c05d39114 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/mapreduce/TestMapReduceBackupCopyJob.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/mapreduce/TestMapReduceBackupCopyJob.java @@ -20,25 +20,19 @@ import static org.apache.hadoop.hbase.backup.mapreduce.MapReduceBackupCopyJob.BACKUP_COPY_OPTION_PREFIX; import static org.apache.hadoop.tools.DistCpConstants.CONF_LABEL_DIRECT_WRITE; import static org.apache.hadoop.tools.DistCpConstants.CONF_LABEL_MAX_MAPS; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.List; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.HBaseClassTestRule; 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; import org.apache.hbase.thirdparty.com.google.common.collect.ImmutableList; -@Category(SmallTests.class) +@Tag(SmallTests.TAG) public class TestMapReduceBackupCopyJob { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMapReduceBackupCopyJob.class); - @Test public void testDistCpOptionParsing() { Configuration conf = new Configuration(); @@ -49,7 +43,7 @@ public void testDistCpOptionParsing() { List expectedArgs = ImmutableList. builder().add("-m", "1000").add("-direct").build(); - assertEquals(args, expectedArgs); + assertEquals(expectedArgs, args); } } diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestBackupLogCleaner.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestBackupLogCleaner.java index 41060347b1db..2a2978237777 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestBackupLogCleaner.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestBackupLogCleaner.java @@ -17,9 +17,9 @@ */ package org.apache.hadoop.hbase.backup.master; -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.ArrayList; @@ -30,7 +30,6 @@ import java.util.Set; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HRegionLocation; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -47,26 +46,21 @@ import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.JVMClusterUtil; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; +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(LargeTests.class) +@Tag(LargeTests.TAG) public class TestBackupLogCleaner extends TestBackupBase { - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestBackupLogCleaner.class); - private static final Logger LOG = LoggerFactory.getLogger(TestBackupLogCleaner.class); // implements all test cases in 1 test since incremental full backup/ // incremental backup has dependencies - @BeforeClass + @BeforeAll public static void before() { TEST_UTIL.getConfiguration().setLong(BackupLogCleaner.TS_BUFFER_KEY, 0); } @@ -264,12 +258,12 @@ public void testDoesNotDeleteWALsFromNewServers() throws Exception { List walsAfterNewServer = getListOfWALFiles(TEST_UTIL.getConfiguration()); LOG.info("WALs after adding new server: {}", walsAfterNewServer.size()); - assertTrue("Should have more WALs after new server", - walsAfterNewServer.size() > walsAfterB1.size()); + assertTrue(walsAfterNewServer.size() > walsAfterB1.size(), + "Should have more WALs after new server"); List newServerWALs = new ArrayList<>(walsAfterNewServer); newServerWALs.removeAll(walsAfterB1); - assertFalse("Should have WALs from new server", newServerWALs.isEmpty()); + assertFalse(newServerWALs.isEmpty(), "Should have WALs from new server"); BackupLogCleaner cleaner = new BackupLogCleaner(); cleaner.setConf(TEST_UTIL.getConfiguration()); @@ -277,8 +271,8 @@ public void testDoesNotDeleteWALsFromNewServers() throws Exception { Set deletable = toSet(cleaner.getDeletableFiles(walsAfterNewServer)); for (FileStatus newWAL : newServerWALs) { - assertFalse("WAL from new server should NOT be deletable: " + newWAL.getPath(), - deletable.contains(newWAL)); + assertFalse(deletable.contains(newWAL), + "WAL from new server should NOT be deletable: " + newWAL.getPath()); } } finally { TEST_UTIL.truncateTable(BackupSystemTable.getTableName(TEST_UTIL.getConfiguration())).close(); @@ -302,18 +296,18 @@ public void testCanDeleteFileWithNewServerWALs() { BackupBoundaries boundaries = BackupBoundaries.builder(0L) .addBackupTimestamps(host, backupStartCode, backupStartCode).build(); - assertTrue("WAL older than backup should be deletable", - BackupLogCleaner.canDeleteFile(boundaries, oldWAL)); + assertTrue(BackupLogCleaner.canDeleteFile(boundaries, oldWAL), + "WAL older than backup should be deletable"); // WAL from exactly at the backup boundary Path boundaryWAL = new Path("/hbase/oldWALs/server1%2C60020%2C12345.1000000"); - assertTrue("WAL at boundary should be deletable", - BackupLogCleaner.canDeleteFile(boundaries, boundaryWAL)); + assertTrue(BackupLogCleaner.canDeleteFile(boundaries, boundaryWAL), + "WAL at boundary should be deletable"); // WAL from a server that joined AFTER the backup Path newServerWAL = new Path("/hbase/oldWALs/newserver%2C60020%2C99999.1500000"); - assertFalse("WAL from new server (after backup) should NOT be deletable", - BackupLogCleaner.canDeleteFile(boundaries, newServerWAL)); + assertFalse(BackupLogCleaner.canDeleteFile(boundaries, newServerWAL), + "WAL from new server (after backup) should NOT be deletable"); } @Test diff --git a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestRestoreBackupSystemTable.java b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestRestoreBackupSystemTable.java index 31ded67b4774..8948d3338704 100644 --- a/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestRestoreBackupSystemTable.java +++ b/hbase-backup/src/test/java/org/apache/hadoop/hbase/backup/master/TestRestoreBackupSystemTable.java @@ -17,7 +17,7 @@ */ package org.apache.hadoop.hbase.backup.master; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.HashMap; import java.util.HashSet; @@ -29,17 +29,19 @@ import org.apache.hadoop.hbase.client.Admin; 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.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 TestRestoreBackupSystemTable { + private static final String BACKUP_ROOT = "root"; private static final HBaseTestingUtil UTIL = new HBaseTestingUtil(); - @BeforeClass + @BeforeAll public static void setUp() throws Exception { UTIL.startMiniCluster(); } @@ -69,15 +71,15 @@ public void itRestoresFromSnapshot() throws Exception { BackupSystemTable.restoreFromSnapshot(UTIL.getConnection()); Map> results = table.readLogTimestampMap(BACKUP_ROOT); - assertEquals(results.size(), tables.size()); + assertEquals(tables.size(), results.size()); for (TableName tableName : tables) { Map resultMap = results.get(tableName); - assertEquals(resultMap, rsTimestampMap); + assertEquals(rsTimestampMap, resultMap); } } - @AfterClass + @AfterAll public static void tearDown() throws Exception { UTIL.shutdownMiniCluster(); }