Verify aggregation in tests.

Author: uhafner

src/test/java/edu/hm/hafner/coverage/ClassNodeTest.java

@@ -2,7 +2,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.*;
+import static edu.hm.hafner.coverage.assertions.Assertions.*;
 
 class ClassNodeTest extends AbstractNodeTest {
     @Override
@@ -17,15 +17,16 @@ Node createNode(final String name) {
 
     @Test
     void shouldHandleUnexpectedNodes() {
-        var root = new ClassNode("Class");
+        var classNode = new ClassNode("Class");
         var main = new MethodNode("main", "String...");
-        root.addChild(main);
-        root.addChild(new ClassNode("NestedClass"));
+        classNode.addChild(main);
+        classNode.addChild(new ClassNode("NestedClass"));
 
-        assertThat(root.findMethod("main", "String..."))
+        assertThat(classNode.findMethod("main", "String..."))
                 .isPresent()
                 .containsSame(main);
-        assertThat(root.findMethod("main", "Nothing"))
+        assertThat(classNode.findMethod("main", "Nothing"))
                 .isNotPresent();
+        assertThat(classNode).isNotAggregation();
     }
 }

src/test/java/edu/hm/hafner/coverage/ContainerNodeTest.java

@@ -17,17 +17,16 @@ Node createNode(final String name) {
 
     @Test
     void shouldAggregateSourceFolders() {
-        var root = new ContainerNode("root");
+        var containerNode = new ContainerNode("root");
         var left = new ModuleNode("left");
-        root.addChild(left);
+        containerNode.addChild(left);
         var right = new ModuleNode("right");
-        root.addChild(right);
+        containerNode.addChild(right);
 
-        assertThat(root.getSourceFolders()).isEmpty();
-        assertThat(root.getChildren()).containsExactly(left, right);
+        assertThat(containerNode).hasNoSourceFolders().hasOnlyChildren(left, right).isAggregation();
 
         left.addSource("left/path");
         right.addSource("right/path");
-        assertThat(root.getSourceFolders()).containsExactly("left/path", "right/path");
+        assertThat(containerNode).hasSourceFolders("left/path", "right/path");
     }
 }

src/test/java/edu/hm/hafner/coverage/FileNodeTest.java

@@ -49,7 +49,7 @@ void shouldGetFilePath() {
         folder.addChild(file);
         module.addChild(folder);
 
-        assertThat(file.getRelativePath()).isEqualTo(relativePath);
+        assertThat(file).hasRelativePath(relativePath).isNotAggregation();
         var otherPath = "other";
 
         assertThat(file.getFiles()).containsExactly(relativePath);

src/test/java/edu/hm/hafner/coverage/MethodNodeTest.java

@@ -28,7 +28,8 @@ void shouldCreateMethodCoverageNode() {
                 .hasMethodName("shouldCreateMethodCoverageNode()")
                 .hasSignature("(Ljava/util/Map;)V")
                 .hasLineNumber(16)
-                .hasValidLineNumber();
+                .hasValidLineNumber()
+                .isNotAggregation();
     }
 
     @Test

src/test/java/edu/hm/hafner/coverage/ModuleNodeTest.java

@@ -16,6 +16,7 @@ Metric getMetric() {
     Node createNode(final String name) {
         var moduleNode = new ModuleNode(name);
         moduleNode.addSource("/path/to/sources");
+        assertThat(moduleNode).hasSourceFolders("/path/to/sources").isAggregation();
         return moduleNode;
     }
 

src/test/java/edu/hm/hafner/coverage/PackageNodeTest.java

@@ -21,32 +21,28 @@ Node createNode(final String name) {
      */
     @Test
     void shouldCopyEmpty() {
-        // Given
         String parentName = ".ui.home.model";
         var parent = new PackageNode(parentName);
         var child = new PackageNode("data");
         parent.addChild(child);
 
-        // When
         Node actualEmptyCopy = parent.copy();
 
-        // Then
         assertThat(actualEmptyCopy)
                 .hasName(parentName)
                 .hasNoChildren()
-                .isEqualTo(new PackageNode(parentName));
+                .isEqualTo(new PackageNode(parentName))
+                .isAggregation();
     }
 
     /**
      * Tests the match functionality using a path hashcode.
      */
     @Test
     void shouldMatchPath() {
-        // Given
         String pkgName = "ui.home.model";
         var pkg = new PackageNode(pkgName);
 
-        // When & Then
         assertThat(pkg.matches(PACKAGE, "ui.home.model".hashCode())).isTrue();
         assertThat(pkg.matches(PACKAGE, "test.path".hashCode())).isFalse();
     }