feat(#10): add broader test info

README.md

@@ -40,7 +40,7 @@ public class UserTest {
 }
 ```
 
-The next names will be considered as invalid:
+The next cases will be considered as invalid:
 
 ```java
 public class UserTest {

pom.xml

@@ -86,6 +86,12 @@
       <version>3.24.7</version>
       <scope>compile</scope>
     </dependency>
+    <dependency>
+      <groupId>org.projectlombok</groupId>
+      <artifactId>lombok</artifactId>
+      <version>1.18.24</version>
+      <scope>provided</scope>
+    </dependency>
     <dependency>
       <groupId>org.apache.maven</groupId>
       <artifactId>maven-plugin-api</artifactId>

src/main/java/com/github/lombrozo/testnames/Cases.java

@@ -0,0 +1,24 @@
+package com.github.lombrozo.testnames;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+@FunctionalInterface
+public interface Cases {
+
+    Collection<TestCase> all();
+
+    static Cases correct() {
+        return () -> Arrays.asList(
+            new TestCase.FakeCase("removes"),
+            new TestCase.FakeCase("creates")
+        );
+    }
+
+    static Cases wrong(){
+        return () -> Arrays.asList(
+            new TestCase.FakeCase("remove"),
+            new TestCase.FakeCase("test")
+        );
+    }
+}

src/main/java/com/github/lombrozo/testnames/JavaParserCase.java

@@ -0,0 +1,33 @@
+package com.github.lombrozo.testnames;
+
+import java.nio.file.Path;
+import lombok.Data;
+
+@Data
+class JavaParserCase implements TestCase {
+
+    private final String className;
+    private final String name;
+    private final Path path;
+
+    JavaParserCase(final String className, final String name, final Path path) {
+        this.className = className;
+        this.name = name;
+        this.path = path;
+    }
+
+    @Override
+    public String className() {
+        return this.className;
+    }
+
+    @Override
+    public String name() {
+        return this.name;
+    }
+
+    @Override
+    public Path path() {
+        return this.path;
+    }
+}

src/main/java/com/github/lombrozo/testnames/JavaTestCode.java

@@ -11,27 +11,30 @@
 import java.util.Collection;
 import java.util.List;
 
-public final class JavaTestCode implements Names {
+public final class JavaTestCode implements Cases {
     private final Path path;
 
     public JavaTestCode(final Path path) {
         this.path = path;
     }
 
     @Override
-    public Collection<String> names() {
+    public Collection<TestCase> all() {
         try {
             final CompilationUnit parse = StaticJavaParser.parse(this.path);
             final List<Node> childNodes = parse.getChildNodes();
-            final List<String> names = new ArrayList<>();
+            final List<TestCase> names = new ArrayList<>();
             for (final Node childNode : childNodes) {
                 if (childNode instanceof ClassOrInterfaceDeclaration) {
                     final ClassOrInterfaceDeclaration clazz = (ClassOrInterfaceDeclaration) childNode;
                     clazz.getMethods().forEach(m -> {
                         if (!m.isPrivate() && (
                             m.isAnnotationPresent("Test")
-                                || m.isAnnotationPresent("ParameterizedTest")))
-                            names.add(m.getNameAsString());
+                                || m.isAnnotationPresent("ParameterizedTest"))) {
+
+                            final String name = m.getNameAsString();
+                            names.add(new JavaParserCase(clazz.getNameAsString(), name, this.path));
+                        }
                     });
                 }
             }

src/main/java/com/github/lombrozo/testnames/RuleForAllTests.java

@@ -4,17 +4,17 @@
 
 final class RuleForAllTests implements Rule {
 
-    private final Names tests;
+    private final Cases tests;
 
-    RuleForAllTests(final Names test) {
+    RuleForAllTests(final Cases test) {
         this.tests = test;
     }
 
     @Override
     public void validate() throws WrongTestName {
-        final Collection<String> names = this.tests.names();
-        for (final String test : names) {
-            new PresentSimpleRule(test).validate();
+        final Collection<TestCase> names = this.tests.all();
+        for (final TestCase test : names) {
+            new PresentSimpleRule(test.name()).validate();
         }
     }
 }

src/main/java/com/github/lombrozo/testnames/TestCase.java

@@ -0,0 +1,46 @@
+package com.github.lombrozo.testnames;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public interface TestCase {
+
+    String className();
+
+    String name();
+
+    Path path();
+
+
+    class FakeCase implements TestCase {
+
+        private final String className;
+        private final String name;
+        private final Path path;
+
+        FakeCase(final String name) {
+            this("FakeClass", name, Paths.get("."));
+        }
+
+        FakeCase(final String className, final String name, final Path path) {
+            this.className = className;
+            this.name = name;
+            this.path = path;
+        }
+
+        @Override
+        public String className() {
+            return className;
+        }
+
+        @Override
+        public String name() {
+            return name;
+        }
+
+        @Override
+        public Path path() {
+            return path;
+        }
+    }
+}

src/test/java/com/github/lombrozo/testnames/JavaTestCodeTest.java

@@ -17,10 +17,25 @@ void getsNamesFromSimpleTest(@TempDir final Path temp) throws Exception {
         final String java = "TestSimple.java";
         final Path path = temp.resolve(java);
         Files.write(path, new BytesOf(new ResourceOf(java)).asBytes());
-        final Names names = new JavaTestCode(path);
+        final Cases cases = new JavaTestCode(path);
         MatcherAssert.assertThat(
-            names.names(),
-            Matchers.containsInAnyOrder("creates", "removes", "updates")
+            cases.all(),
+            Matchers.containsInAnyOrder(
+                new JavaParserCase(
+                    "TestSimple",
+                    "creates",
+                    path
+                ), new JavaParserCase(
+                    "TestSimple",
+                    "removes",
+                    path
+                ),
+                new JavaParserCase(
+                    "TestSimple",
+                    "updates",
+                    path
+                )
+            )
         );
     }
 
@@ -29,18 +44,24 @@ void getsNamesFromParameterizedTest(@TempDir final Path temp) throws Exception {
         final String java = "TestParameterized.java";
         final Path path = temp.resolve(java);
         Files.write(path, new BytesOf(new ResourceOf(java)).asBytes());
-        final Names names = new JavaTestCode(path);
+        final Cases cases = new JavaTestCode(path);
         MatcherAssert.assertThat(
-            names.names(),
-            Matchers.containsInAnyOrder("checksCases")
+            cases.all(),
+            Matchers.containsInAnyOrder(
+                new JavaParserCase(
+                    "TestParameterized",
+                    "checksCases",
+                    path
+                )
+            )
         );
     }
 
     @Test
     void throwsExceptionIfFileNotFound(@TempDir final Path temp) throws Exception {
         Assertions.assertThrows(
             IllegalStateException.class,
-            () -> new JavaTestCode(temp.resolve("TestNotFound.java")).names()
+            () -> new JavaTestCode(temp.resolve("TestNotFound.java")).all()
         );
     }
 
@@ -50,8 +71,9 @@ void throwsExceptionIfFileIsNotJava(@TempDir final Path temp) throws Exception {
         Files.write(path, "Not Java".getBytes());
         Assertions.assertThrows(
             IllegalStateException.class,
-            () -> new JavaTestCode(path).names()
+            () -> new JavaTestCode(path).all()
         );
     }
 
+
 }

src/test/java/com/github/lombrozo/testnames/RuleForAllTestsTest.java

@@ -9,7 +9,7 @@ class RuleForAllTestsTest {
     @Test
     void validatesAllWithoutExceptions() {
         try {
-            new RuleForAllTests(() -> Arrays.asList("removes", "creates")).validate();
+            new RuleForAllTests(Cases.correct()).validate();
         } catch (final WrongTestName ex) {
             Assertions.fail(ex);
         }
@@ -19,7 +19,7 @@ void validatesAllWithoutExceptions() {
     void validatesAllWithExceptions() {
         Assertions.assertThrows(
             WrongTestName.class,
-            () -> new RuleForAllTests(() -> Arrays.asList("creates", "test")).validate()
+            () -> new RuleForAllTests(Cases.wrong()).validate()
         );
     }
 }

src/test/resources/TestSimple.java

@@ -2,7 +2,7 @@
 
 import org.junit.jupiter.api.Test;
 
-class TestExample {
+class TestSimple {
     @Test
     void creates() {
     }