Increased Test Coverage for utils... (#1733)

ReflectionUtil, CollectionUtil and AutoAttachExension

Co-authored-by: Leonard Brünings <leonard.bruenings@gradle.com>

Author: AndreasTu

spock-core/src/main/java/org/spockframework/util/ReflectionUtil.java

@@ -19,6 +19,7 @@
 import java.io.File;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.*;
+import java.security.CodeSource;
 import java.util.*;
 
 import org.codehaus.groovy.runtime.MetaClassHelper;
@@ -155,8 +156,13 @@ public static Method getDeclaredMethodBySignature(Class<?> clazz, String name, C
    * Returns the class file for the given class (which has been verified to exist in the returned location),
    * or null if the class file could not be found (e.g. because it is contained in a Jar).
    */
+  @Nullable
   public static File getClassFile(Class<?> clazz) {
-    File dir = new File(clazz.getProtectionDomain().getCodeSource().getLocation().getPath());
+    CodeSource source = clazz.getProtectionDomain().getCodeSource();
+    if (source == null) {
+      return null;
+    }
+    File dir = new File(source.getLocation().getPath());
     if (!dir.isDirectory()) return null; // class file might be contained in Jar
     File clazzFile = new File(dir, clazz.getName().replace('.', File.separatorChar) + ".class");
     return clazzFile.isFile() ? clazzFile : null;

spock-core/src/main/java/spock/mock/AutoAttachExtension.java

@@ -20,7 +20,7 @@
 import spock.lang.Specification;
 
 public class AutoAttachExtension implements IAnnotationDrivenExtension<AutoAttach> {
-  private static MockUtil MOCK_UTIL = new MockUtil();
+  private static final MockUtil MOCK_UTIL = new MockUtil();
 
   @Override
   public void visitFieldAnnotation(AutoAttach annotation, FieldInfo field) {

spock-specs/src/test/groovy/org/spockframework/mock/AutoAttachInvalidUsageSpec.groovy

@@ -17,15 +17,21 @@ package org.spockframework.mock
 
 import org.spockframework.EmbeddedSpecification
 import org.spockframework.runtime.SpockException
+import spock.mock.AutoAttach
 
 class AutoAttachInvalidUsageSpec extends EmbeddedSpecification {
 
+  def "setup"() {
+    runner.addClassImport(AutoAttach)
+  }
+
+
   def "not on shared"() {
     when:
     runner.runSpecBody('''
 
-    @spock.mock.AutoAttach
-    @spock.lang.Shared
+    @AutoAttach
+    @Shared
     List mockShared
 
     def "foo"() {
@@ -38,4 +44,36 @@ class AutoAttachInvalidUsageSpec extends EmbeddedSpecification {
     def ex = thrown(SpockException)
     ex.message == '@AutoAttach is only supported for instance fields (offending field: apackage.ASpec.mockShared)'
   }
+
+  def "null field"() {
+    when:
+    runner.runWithImports("""
+      @Stepwise
+      class NullFieldSpec extends Specification {
+        @AutoAttach
+        def field = null
+
+        def "feature"()  { expect: true }
+      }
+    """)
+    then:
+    SpockException ex = thrown()
+    ex.message == "Cannot AutoAttach 'null' for field field:3"
+  }
+
+  def "No mock value for field"() {
+    when:
+    runner.runWithImports("""
+      @Stepwise
+      class NoMockSpec extends Specification {
+        @AutoAttach
+        def field = "Value"
+
+        def "feature"()  { expect: true }
+      }
+    """)
+    then:
+    SpockException ex = thrown()
+    ex.message == "AutoAttach failed 'Value' is not a mock for field field:3"
+  }
 }

spock-specs/src/test/groovy/org/spockframework/util/CollectionUtilSpec.groovy

@@ -84,4 +84,45 @@ class CollectionUtilSpec extends Specification {
   private toList(iterable) {
     iterable.collect { it }
   }
+
+  def "asSet"() {
+    when:
+    def s = CollectionUtil.asSet(1, 3, 3, 4)
+    then:
+    s instanceof HashSet
+    s.size() == 3
+    s.contains(1)
+    s.contains(3)
+    s.contains(4)
+  }
+
+  def "getFirstElement"() {
+    expect:
+    CollectionUtil.getFirstElement([1, 2, 3]) == 1
+    when:
+    CollectionUtil.getFirstElement([])
+    then:
+    thrown(InternalSpockError)
+  }
+
+  def "getLastElement"() {
+    expect:
+    CollectionUtil.getLastElement([1, 2, 3]) == 3
+    when:
+    CollectionUtil.getLastElement([])
+    then:
+    thrown(InternalSpockError)
+  }
+
+  def "addLastElement"() {
+    when:
+    def l = []
+    CollectionUtil.addLastElement(l, 1)
+    then:
+    l == [1]
+    when:
+    CollectionUtil.addLastElement(l, 2)
+    then:
+    l == [1, 2]
+  }
 }

spock-specs/src/test/groovy/org/spockframework/util/ReflectionUtilSpec.groovy

@@ -14,8 +14,12 @@
 
 package org.spockframework.util
 
+import org.junit.platform.commons.annotation.Testable
 import spock.lang.*
 
+import java.lang.annotation.Annotation
+import java.lang.reflect.Method
+
 class ReflectionUtilSpec extends Specification {
   def "get package name"() {
     expect:
@@ -42,6 +46,7 @@ class ReflectionUtilSpec extends Specification {
     expect:
     ReflectionUtil.isMethodAvailable("java.util.List", "size")
     !ReflectionUtil.isMethodAvailable("java.util.List", "mice")
+    !ReflectionUtil.isMethodAvailable("not.AvailableClass", "size")
   }
 
   def "check if annotation of certain type is present"() {
@@ -200,4 +205,126 @@ class ReflectionUtilSpec extends Specification {
   static class Generics<T> {
     void foo(T one, List<T> two, List<String> three) {}
   }
+
+  def "isAnnotationPresentRecursive"(Class<?> clazz, Class<? extends Annotation> annotation, boolean expectedResult) {
+    expect:
+    ReflectionUtil.isAnnotationPresentRecursive(clazz, annotation) == expectedResult
+    where:
+    clazz              | annotation | expectedResult
+    Object             | Nullable   | false
+    Specification      | Testable   | true
+    ReflectionUtilSpec | Testable   | true
+    ReflectionUtilSpec | Nullable   | false
+    TypeWithAnno       | Narrative  | true
+    SubTypeNoAnno      | Narrative  | true
+  }
+
+  def "getAnnotationRecursive expecting annotation"(Class<?> clazz, Class<? extends Annotation> annotationClass) {
+    when:
+    def anno = ReflectionUtil.getAnnotationRecursive(clazz, annotationClass)
+    then:
+    clazz && annotationClass && anno != null
+    where:
+    clazz              | annotationClass
+    Specification      | Testable
+    ReflectionUtilSpec | Testable
+    TypeWithAnno       | Narrative
+    SubTypeNoAnno      | Narrative
+  }
+
+  def "getAnnotationRecursive expecting none"(Class<?> clazz, Class<? extends Annotation> annotationClass) {
+    when:
+    def anno = ReflectionUtil.getAnnotationRecursive(clazz, annotationClass)
+    then:
+    clazz && annotationClass && anno == null
+    where:
+    clazz              | annotationClass
+    Object             | Nullable
+    ReflectionUtilSpec | Nullable
+  }
+
+  def "collectAnnotationRecursive"(Class<?> clazz, Class<? extends Annotation> annotationClass, int expectedCount) {
+    expect:
+    ReflectionUtil.collectAnnotationRecursive(clazz, annotationClass).size() == expectedCount
+    where:
+    clazz              | annotationClass | expectedCount
+    Object             | Nullable        | 0
+    Specification      | Testable        | 1
+    ReflectionUtilSpec | Testable        | 2
+    ReflectionUtilSpec | Nullable        | 0
+    TypeWithAnno       | Narrative       | 1
+    SubTypeNoAnno      | Narrative       | 1
+    SubTypeWithAnno    | Narrative       | 2
+  }
+
+  @Narrative
+  private static class TypeWithAnno {}
+
+  @Narrative
+  private static class SubTypeWithAnno extends TypeWithAnno {}
+
+  private static class SubTypeNoAnno extends TypeWithAnno {}
+
+  def "validateArguments - wrong argument count"() {
+    when:
+    ReflectionUtil.validateArguments(lookupMethod("methodNoArgs"), "Str")
+    then:
+    IllegalArgumentException ex = thrown()
+    ex.message == "Method 'methodNoArgs([])' can't be called with parameters '[Str]'!"
+  }
+
+  def "validateArguments - incompatible type"() {
+    when: "Incompatible type"
+    ReflectionUtil.validateArguments(lookupMethod("methodOneArg"), 1)
+    then:
+    IllegalArgumentException ex = thrown()
+    ex.message == "Method 'methodOneArg([class java.lang.String])' can't be called with parameters '[1]'!"
+  }
+
+  def "validateArguments - null value on primitive type"() {
+    when: "Null value on primitive type"
+    ReflectionUtil.validateArguments(lookupMethod("methodPrimitiveArg"), [null] as Object[])
+    then:
+    thrown(IllegalArgumentException)
+  }
+
+  def "validateArguments - Correct types"() {
+    when: "Correct types"
+    ReflectionUtil.validateArguments(lookupMethod("methodOneArg"), "Str")
+    then:
+    noExceptionThrown()
+  }
+
+  private Method lookupMethod(String name) {
+    return Objects.requireNonNull(ReflectionUtilSpec.class.getMethods().find { it.name == name })
+  }
+
+  @SuppressWarnings('unused')
+  static void methodNoArgs() {}
+
+  @SuppressWarnings('unused')
+  static void methodOneArg(String s) {}
+
+  @SuppressWarnings('unused')
+  static void methodPrimitiveArg(int value) {}
+
+  def "deepCopyFields errors"() {
+    when:
+    ReflectionUtil.deepCopyFields("Str", 10)
+    then:
+    IllegalArgumentException ex = thrown()
+    ex.message == "source and target are not compatible."
+  }
+
+  def "getClassFile"() {
+    expect:
+    ReflectionUtil.getClassFile(String) == null
+    ReflectionUtil.getClassFile(Specification) == null
+    ReflectionUtil.getClassFile(ReflectionUtilSpec) != null
+  }
+
+  def "isToStringOverridden error"() {
+    expect:
+    !ReflectionUtil.isToStringOverridden(int.class)
+  }
 }