HDDS-10213. Improve assertTrue assertions in remaining integration-test (#6101)

Author: wzhallright

hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTest.java

@@ -117,6 +117,7 @@
 import static org.apache.hadoop.ozone.OzoneConsts.OZONE_URI_DELIMITER;
 import static org.apache.hadoop.ozone.om.exceptions.OMException.ResultCodes.KEY_NOT_FOUND;
 import static org.apache.hadoop.ozone.om.helpers.BucketLayout.FILE_SYSTEM_OPTIMIZED;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
@@ -392,7 +393,7 @@ private void checkInvalidPath(Path path) {
     InvalidPathException pathException = assertThrows(
         InvalidPathException.class, () -> fs.create(path, false)
     );
-    assertTrue(pathException.getMessage().contains("Invalid path Name"));
+    assertThat(pathException.getMessage()).contains("Invalid path Name");
   }
 
   @Test
@@ -466,7 +467,7 @@ public void testRecursiveDelete() throws Exception {
     // delete a dir with sub-file
     try {
       FileStatus[] parents = fs.listStatus(grandparent);
-      assertTrue(parents.length > 0);
+      assertThat(parents.length).isGreaterThan(0);
       fs.delete(parents[0].getPath(), false);
       fail("Must throw exception as dir is not empty!");
     } catch (PathIsNotEmptyDirectoryException pde) {
@@ -537,8 +538,8 @@ private void checkPath(Path path) {
       fs.getFileStatus(path);
       fail("testRecursiveDelete failed");
     } catch (IOException ex) {
-      assertTrue(ex instanceof FileNotFoundException);
-      assertTrue(ex.getMessage().contains("No such file or directory"));
+      assertInstanceOf(FileNotFoundException.class, ex);
+      assertThat(ex.getMessage()).contains("No such file or directory");
     }
   }
 
@@ -748,7 +749,7 @@ public void testListStatusOnLargeDirectory() throws Exception {
     assertEquals(numDirs, fileStatuses.length, "Total directories listed do not match the existing directories");
 
     for (int i = 0; i < numDirs; i++) {
-      assertTrue(paths.contains(fileStatuses[i].getPath().getName()));
+      assertThat(paths).contains(fileStatuses[i].getPath().getName());
     }
   }
 
@@ -1003,7 +1004,7 @@ public void testSeekOnFileLength() throws IOException {
       fs.open(fileNotExists);
       fail("Should throw FileNotFoundException as file doesn't exist!");
     } catch (FileNotFoundException fnfe) {
-      assertTrue(fnfe.getMessage().contains("KEY_NOT_FOUND"), "Expected KEY_NOT_FOUND error");
+      assertThat(fnfe.getMessage()).contains("KEY_NOT_FOUND");
     }
   }
 
@@ -1026,12 +1027,16 @@ public void testAllocateMoreThanOneBlock() throws IOException {
       FileStatus fileStatus = fs.getFileStatus(file);
       long blkSize = fileStatus.getBlockSize();
       long fileLength = fileStatus.getLen();
-      assertTrue(fileLength > blkSize, "Block allocation should happen");
+      assertThat(fileLength)
+          .withFailMessage("Block allocation should happen")
+          .isGreaterThan(blkSize);
 
       long newNumBlockAllocations =
               cluster.getOzoneManager().getMetrics().getNumBlockAllocates();
 
-      assertTrue((newNumBlockAllocations > numBlockAllocationsOrg), "Block allocation should happen");
+      assertThat(newNumBlockAllocations)
+          .withFailMessage("Block allocation should happen")
+          .isGreaterThan(numBlockAllocationsOrg);
 
       stream.seek(fileLength);
       assertEquals(-1, stream.read());
@@ -1366,7 +1371,7 @@ public void testRenameDir() throws Exception {
     IllegalArgumentException exception = assertThrows(
         IllegalArgumentException.class,
         () -> fs.rename(new Path(fs.getUri().toString() + "fake" + dir), dest));
-    assertTrue(exception.getMessage().contains("Wrong FS"));
+    assertThat(exception.getMessage()).contains("Wrong FS");
   }
 
   private OzoneKeyDetails getKey(Path keyPath, boolean isDirectory)
@@ -1419,7 +1424,7 @@ public void testGetDirectoryModificationTime()
     for (int i = 0; i < 5; i++) {
       Thread.sleep(10);
       fileStatuses = o3fs.listStatus(mdir1);
-      assertTrue(modificationTime <= fileStatuses[0].getModificationTime());
+      assertThat(modificationTime).isLessThanOrEqualTo(fileStatuses[0].getModificationTime());
     }
   }
 
@@ -1817,7 +1822,7 @@ public void testOzFsReadWrite() throws IOException {
 
     // The timestamp of the newly created file should always be greater than
     // the time when the test was started
-    assertTrue(status.getModificationTime() > currentTime);
+    assertThat(status.getModificationTime()).isGreaterThan(currentTime);
 
     assertFalse(status.isDirectory());
     assertEquals(FsPermission.getFileDefault(), status.getPermission());
@@ -1968,7 +1973,7 @@ void testListStatus2() throws IOException {
     assertChange(initialStats, statistics, Statistic.OBJECTS_LIST.getSymbol(), 2);
     assertEquals(initialListStatusCount + 2, omMetrics.getNumListStatus());
     for (Path p : paths) {
-      assertTrue(Arrays.asList(statusList).contains(fs.getFileStatus(p)));
+      assertThat(Arrays.asList(statusList)).contains(fs.getFileStatus(p));
     }
   }
 
@@ -2006,7 +2011,7 @@ void testOzoneManagerFileSystemInterface() throws IOException {
     // doesn't actually exist on server; if it exists, it will be a fixed value.
     // In this case, the dir key exists.
     assertEquals(0, omStatus.getKeyInfo().getDataSize());
-    assertTrue(omStatus.getKeyInfo().getModificationTime() <= currentTime);
+    assertThat(omStatus.getKeyInfo().getModificationTime()).isLessThanOrEqualTo(currentTime);
     assertEquals(new Path(omStatus.getPath()).getName(),
         o3fs.pathToKey(path));
   }
@@ -2020,13 +2025,12 @@ public void testOzoneManagerLocatedFileStatus() throws IOException {
       stream.writeBytes(data);
     }
     FileStatus status = fs.getFileStatus(path);
-    assertTrue(status instanceof LocatedFileStatus);
-    LocatedFileStatus locatedFileStatus = (LocatedFileStatus) status;
-    assertTrue(locatedFileStatus.getBlockLocations().length >= 1);
+    LocatedFileStatus locatedFileStatus = assertInstanceOf(LocatedFileStatus.class, status);
+    assertThat(locatedFileStatus.getBlockLocations().length).isGreaterThanOrEqualTo(1);
 
     for (BlockLocation blockLocation : locatedFileStatus.getBlockLocations()) {
-      assertTrue(blockLocation.getNames().length >= 1);
-      assertTrue(blockLocation.getHosts().length >= 1);
+      assertThat(blockLocation.getNames().length).isGreaterThanOrEqualTo(1);
+      assertThat(blockLocation.getHosts().length).isGreaterThanOrEqualTo(1);
     }
   }
 
@@ -2046,8 +2050,7 @@ void testBlockOffsetsWithMultiBlockFile() throws Exception {
       stream.writeBytes(data);
     }
     FileStatus status = fs.getFileStatus(path);
-    assertTrue(status instanceof LocatedFileStatus);
-    LocatedFileStatus locatedFileStatus = (LocatedFileStatus) status;
+    LocatedFileStatus locatedFileStatus = assertInstanceOf(LocatedFileStatus.class, status);
     BlockLocation[] blockLocations = locatedFileStatus.getBlockLocations();
 
     assertEquals(0, blockLocations[0].getOffset());
@@ -2099,7 +2102,7 @@ void testFileSystemWithObjectStoreLayout() throws IOException {
       config.set(FS_DEFAULT_NAME_KEY, obsRootPath);
 
       IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> FileSystem.get(config));
-      assertTrue(e.getMessage().contains("OBJECT_STORE, which does not support file system semantics"));
+      assertThat(e.getMessage()).contains("OBJECT_STORE, which does not support file system semantics");
     }
   }
 

hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractOzoneFileSystemTestWithFSO.java

@@ -45,8 +45,10 @@
 import java.io.IOException;
 import java.util.ArrayList;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -305,8 +307,8 @@ public void testRenameParentDirModificationTime() throws IOException {
         .getModificationTime();
     // rename should change the parent directory of source and object files
     // modification time but not change modification time of the renamed file
-    assertTrue(dir1BeforeMTime < dir1AfterMTime);
-    assertTrue(dir2BeforeMTime < dir2AfterMTime);
+    assertThat(dir1BeforeMTime).isLessThan(dir1AfterMTime);
+    assertThat(dir2BeforeMTime).isLessThan(dir2AfterMTime);
     assertEquals(file1BeforeMTime, file1AfterMTime);
 
     // mv "/dir1/subdir1/" to "/dir2/subdir1/"
@@ -323,8 +325,8 @@ public void testRenameParentDirModificationTime() throws IOException {
     dir2AfterMTime = getFs().getFileStatus(dir2).getModificationTime();
     long subdir1AfterMTime = getFs().getFileStatus(renamedSubdir1)
         .getModificationTime();
-    assertTrue(dir1BeforeMTime < dir1AfterMTime);
-    assertTrue(dir2BeforeMTime < dir2AfterMTime);
+    assertThat(dir1BeforeMTime).isLessThan(dir1AfterMTime);
+    assertThat(dir2BeforeMTime).isLessThan(dir2AfterMTime);
     assertEquals(subdir1BeforeMTime, subdir1AfterMTime);
   }
 
@@ -379,7 +381,7 @@ private void renameAndAssert(OMMetadataManager omMgr,
     long bucketAfterMTime = omBucketInfo.getModificationTime();
     long fileAfterMTime = getFs().getFileStatus(to).getModificationTime();
     if (exceptChangeMtime) {
-      assertTrue(bucketBeforeMTime < bucketAfterMTime);
+      assertThat(bucketBeforeMTime).isLessThan(bucketAfterMTime);
     } else {
       assertEquals(bucketBeforeMTime, bucketAfterMTime);
     }
@@ -434,7 +436,7 @@ public void testMultiLevelDirs() throws Exception {
     long d6ObjectID =
         verifyDirKey(volumeId, bucketId, d4ObjectID,
                 "d6", "/d1/d2/d3/d4/d6", dirKeys, omMgr);
-    assertTrue(d5ObjectID != d6ObjectID, "Wrong objectIds for sub-dirs[" + d5ObjectID + "/d5, " + d6ObjectID
+    assertNotEquals(d5ObjectID, d6ObjectID, "Wrong objectIds for sub-dirs[" + d5ObjectID + "/d5, " + d6ObjectID
         + "/d6] of same parent!");
 
     assertEquals(6, getCluster().getOzoneManager().getMetrics().getNumKeys(), "Wrong OM numKeys metrics");
@@ -520,10 +522,10 @@ public void testFSDeleteLogWarnNoExist() throws Exception {
     GenericTestUtils.LogCapturer logCapture = GenericTestUtils.LogCapturer
         .captureLogs(BasicOzoneClientAdapterImpl.LOG);
     getFs().delete(new Path("/d1/d3/noexist/"), true);
-    assertTrue(logCapture.getOutput().contains(
-        "delete key failed Unable to get file status"));
-    assertTrue(logCapture.getOutput().contains(
-        "WARN  ozone.BasicOzoneClientAdapterImpl"));
+    assertThat(logCapture.getOutput()).contains(
+        "delete key failed Unable to get file status");
+    assertThat(logCapture.getOutput()).contains(
+        "WARN  ozone.BasicOzoneClientAdapterImpl");
   }
 
   private void verifyOMFileInfoFormat(OmKeyInfo omKeyInfo, String fileName,
@@ -546,7 +548,7 @@ long verifyDirKey(long volumeId, long bucketId, long parentId,
         " using dbKey: " + dbKey);
     assertEquals(parentId, dirInfo.getParentObjectID(), "Parent Id mismatches");
     assertEquals(dirKey, dirInfo.getName(), "Mismatches directory name");
-    assertTrue(dirInfo.getCreationTime() > 0, "Mismatches directory creation time param");
+    assertThat(dirInfo.getCreationTime()).isGreaterThan(0);
     assertEquals(dirInfo.getCreationTime(), dirInfo.getModificationTime());
     return dirInfo.getObjectID();
   }

hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/AbstractRootedOzoneFileSystemTest.java

@@ -124,6 +124,7 @@
 import static org.apache.hadoop.ozone.security.acl.IAccessAuthorizer.ACLType.WRITE;
 import static org.apache.hadoop.ozone.security.acl.IAccessAuthorizer.ACLType.DELETE;
 import static org.apache.hadoop.ozone.security.acl.IAccessAuthorizer.ACLType.LIST;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -774,7 +775,7 @@ void testListStatusOnLargeDirectory() throws Exception {
       assertEquals(numDirs, fileStatuses.length, "Total directories listed do not match the existing directories");
 
       for (int i = 0; i < numDirs; i++) {
-        assertTrue(paths.contains(fileStatuses[i].getPath().getName()));
+        assertThat(paths).contains(fileStatuses[i].getPath().getName());
       }
     } finally {
       // Cleanup
@@ -1107,7 +1108,7 @@ void testListStatusRootAndVolumeRecursive() throws IOException {
    */
   private FileStatus[] customListStatus(Path f, boolean recursive,
       String startPath, int numEntries) throws IOException {
-    assertTrue(numEntries > 0);
+    assertThat(numEntries).isGreaterThan(0);
     LinkedList<FileStatus> statuses = new LinkedList<>();
     List<FileStatus> tmpStatusList;
     do {
@@ -1484,9 +1485,9 @@ void testSymlinkList() throws Exception {
                new GenericTestUtils.SystemOutCapturer()) {
         String linkPathStr = rootPath + destVolume;
         ToolRunner.run(shell, new String[]{"-ls", linkPathStr});
-        assertTrue(capture.getOutput().contains("drwxrwxrwx"));
-        assertTrue(capture.getOutput().contains(linkPathStr +
-            OZONE_URI_DELIMITER + srcBucket));
+        assertThat(capture.getOutput()).contains("drwxrwxrwx");
+        assertThat(capture.getOutput()).contains(linkPathStr +
+            OZONE_URI_DELIMITER + srcBucket);
       } finally {
         shell.close();
       }
@@ -1507,12 +1508,12 @@ void testSymlinkList() throws Exception {
         String linkPathStr = rootPath + destVolume;
         ToolRunner.run(shell, new String[]{"-ls", "-R",
             linkPathStr + OZONE_URI_DELIMITER + srcBucket});
-        assertTrue(capture.getOutput().contains("drwxrwxrwx"));
-        assertTrue(capture.getOutput().contains(linkPathStr +
-            OZONE_URI_DELIMITER + srcBucket));
-        assertTrue(capture.getOutput().contains("-rw-rw-rw-"));
-        assertTrue(capture.getOutput().contains(linkPathStr +
-            OZONE_URI_DELIMITER + srcBucket + OZONE_URI_DELIMITER + key));
+        assertThat(capture.getOutput()).contains("drwxrwxrwx");
+        assertThat(capture.getOutput()).contains(linkPathStr +
+            OZONE_URI_DELIMITER + srcBucket);
+        assertThat(capture.getOutput()).contains("-rw-rw-rw-");
+        assertThat(capture.getOutput()).contains(linkPathStr +
+            OZONE_URI_DELIMITER + srcBucket + OZONE_URI_DELIMITER + key);
       } finally {
         shell.close();
       }
@@ -1676,7 +1677,7 @@ void testDeleteBucketLink() throws Exception {
     // confirm link is gone
     FileNotFoundException exception = assertThrows(FileNotFoundException.class,
         () -> fs.getFileStatus(dirPathLink));
-    assertTrue(exception.getMessage().contains("File not found."));
+    assertThat(exception.getMessage()).contains("File not found.");
 
     // Cleanup
     fs.delete(bucketPath1, true);
@@ -1926,15 +1927,15 @@ void testTrash() throws Exception {
     }, 1000, 180000);
 
     if (isBucketFSOptimized) {
-      assertTrue(getOMMetrics()
-          .getNumTrashAtomicDirRenames() > prevNumTrashAtomicDirRenames);
+      assertThat(getOMMetrics().getNumTrashAtomicDirRenames())
+          .isGreaterThan(prevNumTrashAtomicDirRenames);
     } else {
       // This condition should pass after the checkpoint
-      assertTrue(getOMMetrics()
-          .getNumTrashRenames() > prevNumTrashRenames);
+      assertThat(getOMMetrics().getNumTrashRenames())
+          .isGreaterThan(prevNumTrashRenames);
       // With new layout version, file renames wouldn't be counted
-      assertTrue(getOMMetrics()
-          .getNumTrashFilesRenames() > prevNumTrashFileRenames);
+      assertThat(getOMMetrics().getNumTrashFilesRenames())
+          .isGreaterThan(prevNumTrashFileRenames);
     }
 
     // wait for deletion of checkpoint dir
@@ -1993,7 +1994,7 @@ void testCreateWithInvalidPaths() {
   private void checkInvalidPath(Path path) {
     InvalidPathException exception = assertThrows(InvalidPathException.class,
         () -> fs.create(path, false));
-    assertTrue(exception.getMessage().contains("Invalid path Name"));
+    assertThat(exception.getMessage()).contains("Invalid path Name");
   }
 
 
@@ -2445,7 +2446,7 @@ void testSnapshotDiff() throws Exception {
         IllegalArgumentException.class,
         () -> ofs.getSnapshotDiffReport(volumePath1, finalFromSnap,
             finalToSnap));
-    assertTrue(exception.getMessage().contains(errorMsg));
+    assertThat(exception.getMessage()).contains(errorMsg);
   }
 
   @Test

hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/fs/ozone/TestDirectoryDeletingServiceWithFSO.java

@@ -57,7 +57,9 @@
 import java.util.concurrent.TimeoutException;
 import java.util.function.LongSupplier;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_ACL_ENABLED;
@@ -177,7 +179,7 @@ public void testDeleteEmptyDirectory() throws Exception {
       assertEquals(root.getName(), iterator.next().getValue().getName());
     }
 
-    assertTrue(dirDeletingService.getRunCount().get() > 1);
+    assertThat(dirDeletingService.getRunCount().get()).isGreaterThan(1);
   }
 
   /**
@@ -244,9 +246,9 @@ public void testDeleteWithLargeSubPathsThanBatchSize() throws Exception {
     assertSubPathsCount(dirDeletingService::getDeletedDirsCount, 19);
 
     long elapsedRunCount = dirDeletingService.getRunCount().get() - preRunCount;
-    assertTrue(dirDeletingService.getRunCount().get() > 1);
+    assertThat(dirDeletingService.getRunCount().get()).isGreaterThan(1);
     // Ensure dir deleting speed, here provide a backup value for safe CI
-    assertTrue(elapsedRunCount >= 7);
+    assertThat(elapsedRunCount).isGreaterThanOrEqualTo(7);
   }
 
   @Test
@@ -295,7 +297,7 @@ public void testDeleteWithMultiLevels() throws Exception {
     assertSubPathsCount(dirDeletingService::getMovedDirsCount, 2);
     assertSubPathsCount(dirDeletingService::getDeletedDirsCount, 5);
 
-    assertTrue(dirDeletingService.getRunCount().get() > 1);
+    assertThat(dirDeletingService.getRunCount().get()).isGreaterThan(1);
   }
 
   @Test
@@ -549,8 +551,8 @@ private void checkPath(Path path) {
       fs.getFileStatus(path);
       fail("testRecursiveDelete failed");
     } catch (IOException ex) {
-      assertTrue(ex instanceof FileNotFoundException);
-      assertTrue(ex.getMessage().contains("No such file or directory"));
+      assertInstanceOf(FileNotFoundException.class, ex);
+      assertThat(ex.getMessage()).contains("No such file or directory");
     }
   }