Add instance methods check (#2)

Author: karczews

gradle.properties

@@ -2,8 +2,8 @@ POM_NAME=UtilsVerifier
 POM_ARTIFACT_ID=utilsverifier
 POM_PACKAGING=jar
 
-VERSION_NAME=0.0.1-SNAPSHOT
-VERSION_CODE=1
+VERSION_NAME=0.0.2-SNAPSHOT
+VERSION_CODE=2
 GROUP=com.github.karczews
 
 POM_DESCRIPTION=UtilsVerifier can be used in JUnit 4 unit tests to verify whether given util class is well formed one.

src/main/java/com/github/karczews/utilsverifier/UtilsVerifier.java

@@ -15,6 +15,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 
 /**
@@ -39,6 +40,7 @@ public class UtilsVerifier<T> {
     private boolean suppressOnlyOneConstructorCheck = false;
     private boolean suppressPrivateConstructorCheck = false;
     private boolean suppressInstanceFieldCheck = false;
+    private boolean suppressInstanceMethodCheck = false;
 
     private UtilsVerifier(final Class<T> type) {
         classUnderTest = type;
@@ -62,6 +64,7 @@ public void verify() {
         hasOnlyOneConstructor();
         verifyPrivateConstructor();
         hasNoInstanceFields();
+        hasNoInstanceMethods();
     }
 
     /**
@@ -117,6 +120,17 @@ public UtilsVerifier<T> suppressInstanceFieldCheck(final boolean suppressCheck)
         return this;
     }
 
+    /**
+     * Suppress instance method verification.
+     * Use if util class is allowed to have instance methods.
+     *
+     * @param suppressCheck true if check should be suppressed, false otherwise
+     */
+    public UtilsVerifier<T> suppressInstanceMethodCheck(final boolean suppressCheck) {
+        suppressInstanceMethodCheck = suppressCheck;
+        return this;
+    }
+
     private void checkIfClassIsFinal() {
         if (suppressFinalClassCheck) return;
         if (!Modifier.isFinal(classUnderTest.getModifiers())) {
@@ -164,10 +178,22 @@ private void hasNoInstanceFields() {
         for (int index = 0; index < fields.length; index++) {
             final Field field = fields[index];
             if (!Modifier.isStatic(field.getModifiers())) {
-                throw new AssertionError(classUnderTest.getName() + " contains instance field " + field.getName());
+                throw new AssertionError(classUnderTest.getName()
+                        + " contains instance field " + field.getName());
+            }
+        }
+    }
+
+    private void hasNoInstanceMethods() {
+        if (suppressInstanceMethodCheck) return;
+        final Method[] methods = classUnderTest.getDeclaredMethods();
+        for (int index = 0; index < methods.length; index++) {
+            final Method method = methods[index];
+            if (!Modifier.isStatic(method.getModifiers())) {
+                throw new AssertionError(classUnderTest.getName()
+                        + " contains instance method " + method.getName());
             }
         }
     }
-    //TODO: add check for non-static methods
     //TODO: add check for mutable static fields
 }

src/test/java/com/github/karczews/utilsverifier/UtilsVerifierTest.java

@@ -13,18 +13,25 @@
 package com.github.karczews.utilsverifier;
 
 
+import com.github.karczews.utilsverifier.subjects.AbstractClass;
+import com.github.karczews.utilsverifier.subjects.DefaultConstructor;
 import com.github.karczews.utilsverifier.subjects.InstanceFields;
+import com.github.karczews.utilsverifier.subjects.InstanceMethods;
 import com.github.karczews.utilsverifier.subjects.MultipleConstructors;
 import com.github.karczews.utilsverifier.subjects.NonFinalClass;
+import com.github.karczews.utilsverifier.subjects.NonPrivateConstructor;
 import com.github.karczews.utilsverifier.subjects.ThrowingConstructor;
 import com.github.karczews.utilsverifier.subjects.WellFormed;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
+import org.mockito.Mockito;
 
 import static org.hamcrest.core.AllOf.allOf;
 import static org.hamcrest.core.StringContains.containsString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
 
 public class UtilsVerifierTest {
 
@@ -51,6 +58,35 @@ public void shouldFailOnInstanceFields() {
                 .verify();
     }
 
+    @Test
+    public void shouldFailOnInstanceMethod() {
+        expectedException.expect(AssertionError.class);
+        expectedException.expectMessage(containsString("instanceMethod"));
+
+        suppressedVerifier(InstanceMethods.class)
+                .suppressInstanceMethodCheck(false)
+                .verify();
+    }
+
+    @Test
+    public void shouldFailWhenNoConstructor() {
+        expectedException.expect(AssertionError.class);
+
+        suppressedVerifier(DefaultConstructor.class)
+                .suppressPrivateConstructorCheck(false)
+                .verify();
+    }
+
+    @Test
+    public void shouldFailWhenNoPrivateConstructor() {
+        expectedException.expect(AssertionError.class);
+        expectedException.expectMessage(containsString("should be private"));
+
+        suppressedVerifier(NonPrivateConstructor.class)
+                .suppressPrivateConstructorCheck(false)
+                .verify();
+    }
+
     @Test
     public void shouldFailOnMultipleConstructors() {
         expectedException.expect(AssertionError.class);
@@ -95,11 +131,27 @@ public void shouldPassForWellFormedUtil() {
         UtilsVerifier.forClass(WellFormed.class).verify();
     }
 
+    @Test
+    public void shouldThrowIllegalStateExceptionOnInstantiationReflectionProblems() {
+        expectedException.expect(IllegalStateException.class);
+
+        suppressedVerifier(AbstractClass.class).verify();
+    }
+
+    @Test
+    public void shouldFailOnClassWithNoConstructor() {
+        expectedException.expect(AssertionError.class);
+        expectedException.expectMessage(containsString("has no constructor"));
+
+        suppressedVerifier(Runnable.class).verify();
+    }
+
     private static <T> UtilsVerifier<T> suppressedVerifier(final Class<T> type) {
         return UtilsVerifier.forClass(type)
                 .suppressFinalClassCheck(true)
                 .suppressOnlyOneConstructorCheck(true)
                 .suppressPrivateConstructorCheck(true)
-                .suppressInstanceFieldCheck(true);
+                .suppressInstanceFieldCheck(true)
+                .suppressInstanceMethodCheck(true);
     }
 }

src/test/java/com/github/karczews/utilsverifier/subjects/AbstractClass.java

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2017-present, UtilsVerifier Contributors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations under the License.
+ */
+package com.github.karczews.utilsverifier.subjects;
+
+public abstract class AbstractClass {
+}

src/test/java/com/github/karczews/utilsverifier/subjects/DefaultConstructor.java

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2017-present, UtilsVerifier Contributors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations under the License.
+ */
+package com.github.karczews.utilsverifier.subjects;
+
+public final class DefaultConstructor {
+}

src/test/java/com/github/karczews/utilsverifier/subjects/InstanceMethods.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2017-present, UtilsVerifier Contributors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations under the License.
+ */
+package com.github.karczews.utilsverifier.subjects;
+
+public final class InstanceMethods {
+
+    private void instanceMethod() {
+    }
+
+    private InstanceMethods() {
+    }
+}

src/test/java/com/github/karczews/utilsverifier/subjects/NonPrivateConstructor.java

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2017-present, UtilsVerifier Contributors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations under the License.
+ */
+package com.github.karczews.utilsverifier.subjects;
+
+public final class NonPrivateConstructor {
+    public NonPrivateConstructor() {
+    }
+}