add some support for toString coverage

restup · Apr 9, 2018 · d8669a4 · d8669a4
1 parent 4d7ca4d
commit d8669a4
Show file tree

Hide file tree

Showing 8 changed files with 163 additions and 83 deletions.
diff --git a/up-core/src/test/java/com/github/restup/registry/ResourceTest.java b/up-core/src/test/java/com/github/restup/registry/ResourceTest.java
@@ -4,27 +4,22 @@
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
-import java.util.Arrays;
-import java.util.List;
-import org.junit.Test;
+
 import com.github.restup.annotations.ApiName;
 import com.github.restup.mapping.MappedClass;
 import com.github.restup.path.ResourcePathsProvider;
 import com.github.restup.query.Pagination;
 import com.github.restup.registry.settings.ControllerMethodAccess;
 import com.github.restup.registry.settings.ServiceMethodAccess;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
 
 public class ResourceTest {
 
-
-    @Test
-    public void testToString() {
-        assertEquals("foo", foo().toString());
-    }
-
     @Test
     public void testGetRelationshipsTo() {
-        Resource<Foo, Long> resource = foo();
+        Resource<Foo, Long> resource = this.foo();
         assertEquals(0, resource.getRelationshipsTo().size());
 
 
@@ -35,7 +30,7 @@ public void testGetRelationshipsTo() {
         when(registry.getSettings()).thenReturn(mapBackedRegistry().getSettings());
         when(registry.getRelationships("foo")).thenReturn(relationships);
 
-        resource = foo(registry);
+        resource = this.foo(registry);
         assertEquals(relationships, resource.getRelationships());
         assertEquals(0, resource.getRelationshipsTo().size());
 
@@ -45,12 +40,12 @@ public void testGetRelationshipsTo() {
 
     @Test
     public void testDefaultBuilderTyped() {
-        test(Resource.builder(Foo.class, Long.class));
+        this.test(Resource.builder(Foo.class, Long.class));
     }
 
     @Test
     public void testDefaultBuilder() {
-        test(Resource.builder(Foo.class));
+        this.test(Resource.builder(Foo.class));
     }
 
     public <T> void test(Resource.Builder<T, ?> builder) {
@@ -65,7 +60,7 @@ public <T> void test(Resource.Builder<T, ?> builder) {
     }
 
     private Resource<Foo, Long> foo() {
-        return foo(mapBackedRegistry());
+        return this.foo(mapBackedRegistry());
     }
 
     private Resource<Foo, Long> foo(ResourceRegistry registry) {
@@ -95,7 +90,6 @@ public void testBuilder() {
 
     }
 
-    @SuppressWarnings("unused")
     @ApiName("foo")
     private final static class Foo {
 

diff --git a/up-test/pom.xml b/up-test/pom.xml
@@ -1,5 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns="http://maven.apache.org/POM/4.0.0"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>up-parent</artifactId>
         <groupId>com.github.restup</groupId>

diff --git a/up-test/src/main/java/com/github/restup/test/BasicApiRequest.java b/up-test/src/main/java/com/github/restup/test/BasicApiRequest.java
@@ -1,7 +1,7 @@
 package com.github.restup.test;
 
-import java.util.Map;
 import com.github.restup.test.resource.Contents;
+import java.util.Map;
 
 class BasicApiRequest implements ApiRequest {
 
@@ -25,27 +25,37 @@ class BasicApiRequest implements ApiRequest {
 
     @Override
     public HttpMethod getMethod() {
-        return method;
+        return this.method;
     }
 
     @Override
     public Contents getBody() {
-        return body;
+        return this.body;
     }
 
     @Override
     public Map<String, String[]> getHeaders() {
-        return headers;
+        return this.headers;
     }
 
     @Override
     public boolean isHttps() {
-        return https;
+        return this.https;
     }
 
     @Override
     public String getUrl() {
-        return url;
+        return this.url;
     }
 
+    @Override
+    public String toString() {
+        return "BasicApiRequest{" +
+            "method=" + this.method +
+            ", headers=" + this.headers +
+            ", url='" + this.url + '\'' +
+            ", body=" + this.body +
+            ", https=" + this.https +
+            '}';
+    }
 }
diff --git a/up-test/src/main/java/com/github/restup/test/assertions/Assertions.java b/up-test/src/main/java/com/github/restup/test/assertions/Assertions.java
@@ -3,19 +3,24 @@
 import static org.assertj.core.api.Assertions.catchThrowable;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
+import nl.jqno.equalsverifier.EqualsVerifier;
 import org.assertj.core.api.AbstractThrowableAssert;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
-import nl.jqno.equalsverifier.EqualsVerifier;
 
 /**
  * Provides convenience methods for testing using various open source projects using sensible defaults
  * or offering more concise test methods.
  */
 public class Assertions {
 
+    private Assertions() {
+        super();
+    }
+
     /**
      * Assert that the classes have a private constructor
      * @param classes to test
@@ -44,9 +49,9 @@ public static void assertPrivateConstructor(Class<?>... classes) {
      */
     public static <E extends Throwable> AbstractThrowableAssert<?, ?> assertThrows(ThrowingCallable f, Class<E> e) {
         Throwable thrownException = catchThrowable(f);
-        
+
         return org.assertj.core.api.Assertions.assertThat(thrownException)
-                .isInstanceOf(e);
+            .isInstanceOf(e);
     }
 
     /**
@@ -90,9 +95,5 @@ public static void assertHashCodeEquals(Class<?>... classes) {
             assertHashCodeEquals(clazz);
         }
     }
-
-    private Assertions() {
-        super();
-    }
 
 }
diff --git a/up-test/src/main/java/com/github/restup/test/assertions/PojoAssertions.java b/up-test/src/main/java/com/github/restup/test/assertions/PojoAssertions.java
@@ -1,8 +1,5 @@
 package com.github.restup.test.assertions;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
 import com.openpojo.reflection.PojoClass;
 import com.openpojo.reflection.PojoClassFilter;
 import com.openpojo.reflection.filters.FilterClassName;
@@ -22,6 +19,9 @@
 import com.openpojo.validation.test.impl.DefaultValuesNullTester;
 import com.openpojo.validation.test.impl.GetterTester;
 import com.openpojo.validation.test.impl.SetterTester;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 /**
  * Assertions using openpojo with sensible defaults and utility methods 
@@ -40,15 +40,11 @@ public class PojoAssertions {
     private int expectedClasses;
 
     PojoAssertions() {
-        classes = new ArrayList<>();
-        rules = new ArrayList<>();
-        testers = new ArrayList<>();
-        includeDefaultTesters = true;
-        includeDefaultRules = true;
-    }
-
-    private PojoAssertions me() {
-        return this;
+        this.classes = new ArrayList<>();
+        this.rules = new ArrayList<>();
+        this.testers = new ArrayList<>();
+        this.includeDefaultTesters = true;
+        this.includeDefaultRules = true;
     }
 
     public static List<Rule> defaultRules() {
@@ -64,100 +60,106 @@ public static List<Tester> defaultTesters() {
         // Add Testers to validate behaviour for POJO_PACKAGE
         // See com.openpojo.validation.test.impl for more ...
         return Arrays.asList(
-                new SetterTester(), new GetterTester(), new DefaultValuesNullTester());
+            new SetterTester(), new GetterTester(), new DefaultValuesNullTester(),
+            new ToStringTester());
+    }
+
+    private PojoAssertions me() {
+        return this;
     }
 
     public PojoAssertions with(Rule... rules) {
         this.rules.addAll(Arrays.asList(rules));
-        return me();
+        return this.me();
     }
 
     public PojoAssertions with(Tester... testers) {
         this.testers.addAll(Arrays.asList(testers));
-        return me();
+        return this.me();
     }
 
     public PojoAssertions add(Class<?>... classes) {
         for (Class<?> clazz : classes) {
             this.classes.add(PojoClassFactory.getPojoClass(clazz));
-            expectedClasses++;
+            this.expectedClasses++;
         }
-        return me();
+        return this.me();
     }
 
     public PojoAssertions addMatching(int expected, String packageName, String regex) {
-        return add(expected, new FilterClassName("^" + packageName + "\\." + regex), packageName);
+        return this
+            .add(expected, new FilterClassName("^" + packageName + "\\." + regex), packageName);
     }
 
     public PojoAssertions addMatching(int expected, Class<?> relativeTo, String regex) {
         String packageName = relativeTo.getPackage().getName();
-        return addMatching(expected, packageName, regex);
+        return this.addMatching(expected, packageName, regex);
     }
 
     public PojoAssertions addMatchingRecursively(int expected, String packageName, String regex) {
-        return addRecursively(expected, new FilterClassName(regex), packageName);
+        return this.addRecursively(expected, new FilterClassName(regex), packageName);
     }
 
     public PojoAssertions add(int expected, String... packages) {
-        return add(expected, new FilterPackageInfo(), packages);
+        return this.add(expected, new FilterPackageInfo(), packages);
     }
 
     public PojoAssertions add(int expected, PojoClassFilter pojoClassFilter, String... packages) {
-        expectedClasses += expected;
+        this.expectedClasses += expected;
         for (String pkg : packages) {
             this.classes.addAll(PojoClassFactory.getPojoClasses(pkg, pojoClassFilter));
         }
-        return me();
+        return this.me();
     }
 
     public PojoAssertions addRecursively(int expected, String... packages) {
-        return addRecursively(expected, new FilterPackageInfo(), packages);
+        return this.addRecursively(expected, new FilterPackageInfo(), packages);
     }
 
     public PojoAssertions addRecursively(int expected, PojoClassFilter pojoClassFilter, String... packages) {
-        expectedClasses += expected;
+        this.expectedClasses += expected;
         for (String pkg : packages) {
             this.classes.addAll(PojoClassFactory.getPojoClassesRecursively(pkg, pojoClassFilter));
         }
-        return me();
+        return this.me();
     }
 
     public PojoAssertions includeDefaultRules(boolean b) {
         this.includeDefaultRules = b;
-        return me();
+        return this.me();
     }
 
     public PojoAssertions includeDefaultTesters(boolean b) {
         this.includeDefaultTesters = b;
-        return me();
+        return this.me();
     }
 
     public void validate() {
 
         ValidatorBuilder builder = ValidatorBuilder.create();
 
-        addRules(builder);
+        this.addRules(builder);
 
-        addTesters(builder);
+        this.addTesters(builder);
 
-        Affirm.affirmEquals("Classes added / removed?", expectedClasses, classes.size());
+        Affirm.affirmEquals("Classes added / removed?", this.expectedClasses, this.classes.size());
 
         Validator validator = builder.build();
-        validator.validate(classes);
+        validator.validate(this.classes);
     }
 
     private void addTesters(ValidatorBuilder validator) {
-        List<Tester> validatorTesters = new ArrayList<>(testers);
-        if (includeDefaultTesters) {
+        List<Tester> validatorTesters = new ArrayList<>(this.testers);
+        if (this.includeDefaultTesters) {
             validatorTesters.addAll(defaultTesters());
         }
 
         validatorTesters.forEach(t -> validator.with(t));
     }
 
     private void addRules(ValidatorBuilder validator) {
-        List<Rule> validatorRules = new ArrayList<>(rules);
-        if (includeDefaultRules) {
+        List<Rule> validatorRules = new ArrayList<>(this.rules);
+        if (this.includeDefaultRules) {
             validatorRules.addAll(defaultRules());
         }
         validatorRules.forEach(r -> validator.with(r));