rename asserts to checks

move the checks outside their package

Author: imetaxas

pom.xml

@@ -4,16 +4,17 @@
 
   <groupId>com.yanimetaxas</groupId>
   <artifactId>realitycheck</artifactId>
-  <version>0.5.8-SNAPSHOT</version>
+  <version>0.5.9-SNAPSHOT</version>
 
     <name>Reality Check</name>
     <url>https://github.com/imetaxas/realitycheck</url>
+    <description>Fluent Java Code Test Checks.</description>
 
     <scm>
         <url>https://github.com/imetaxas/realitycheck</url>
         <connection>scm:git:git@github.com:imetaxas/realitycheck.git</connection>
         <developerConnection>scm:git:git@github.com:imetaxas/realitycheck.git</developerConnection>
-        <tag>realitycheck-0.5.8</tag>
+        <tag>realitycheck-0.5.9</tag>
     </scm>
 
     <issueManagement>
@@ -25,8 +26,6 @@
         <url>https://travis-ci.org/imetaxas/realitycheck</url>
     </ciManagement>
 
-    <description>https://github.com/imetaxas/realitycheck.git</description>
-
     <parent>
         <groupId>org.sonatype.oss</groupId>
         <artifactId>oss-parent</artifactId>
@@ -41,17 +40,24 @@
         </license>
     </licenses>
 
+    <organization>
+      <name>Yani (Ioannis) Metaxas</name>
+      <url>http://yanimetaxas.com</url>
+    </organization>
+
     <developers>
         <developer>
             <id>imetaxas</id>
             <name>Yani (Ioannis) Metaxas</name>
             <email>imetaxas@gmail.com</email>
-            <url>http://yanimetaxas.info</url>
+            <url>http://yanimetaxas.com</url>
             <roles>
                 <role>creator</role>
                 <role>developer</role>
             </roles>
             <timezone>+1</timezone>
+            <organization>Yani (Ioannis) Metaxas</organization>
+            <organizationUrl>http://yanimetaxas.com</organizationUrl>
         </developer>
     </developers>
 

src/main/java/com/yanimetaxas/realitycheck/asserter/AbstractAssert.java src/main/java/com/yanimetaxas/realitycheck/AbstractCheck.java

@@ -1,19 +1,19 @@
-package com.yanimetaxas.realitycheck.asserter;
+package com.yanimetaxas.realitycheck;
 
 import com.yanimetaxas.realitycheck.util.GenericClass;
 import java.util.Optional;
 
 /**
  * @author yanimetaxas
  */
-public abstract class AbstractAssert<SELF extends AbstractAssert<SELF, ACTUAL>, ACTUAL> implements
-    Assertable<SELF, ACTUAL> {
+public abstract class AbstractCheck<SELF extends AbstractCheck<SELF, ACTUAL>, ACTUAL> implements
+    Checkable<SELF, ACTUAL> {
 
   final ACTUAL actual;
   final SELF self;
   final String customMessage;
 
-  public AbstractAssert(ACTUAL actual, String customMessage) {
+  AbstractCheck(ACTUAL actual, String customMessage) {
     GenericClass<SELF> genericClass = new GenericClass(getClass());
     self = genericClass.getType().cast(this);
     this.actual = actual;

src/main/java/com/yanimetaxas/realitycheck/asserter/AbstractReadableAssert.java src/main/java/com/yanimetaxas/realitycheck/AbstractReadableCheck.java

@@ -1,7 +1,7 @@
-package com.yanimetaxas.realitycheck.asserter;
+package com.yanimetaxas.realitycheck;
 
 import com.yanimetaxas.realitycheck.exception.ValidationException;
-import com.yanimetaxas.realitycheck.strategy.validation.ValidationStrategy;
+import com.yanimetaxas.realitycheck.strategy.ValidationStrategy;
 import com.yanimetaxas.realitycheck.util.IoUtil;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
@@ -13,31 +13,32 @@
 /**
  * @author yanimetaxas
  */
-public abstract class AbstractReadableAssert<SELF extends AbstractReadableAssert<SELF, ACTUAL, STRATEGY>, ACTUAL, STRATEGY> extends AbstractAssert<SELF, ACTUAL> {
+public abstract class AbstractReadableCheck<SELF extends AbstractReadableCheck<SELF, ACTUAL, STRATEGY>, ACTUAL, STRATEGY> extends
+    AbstractCheck<SELF, ACTUAL> {
 
   private final byte[] actualContent;
   private final ValidationStrategy validationStrategy;
 
-  public AbstractReadableAssert(ACTUAL actual, String message) throws AssertionError {
+  AbstractReadableCheck(ACTUAL actual, String message) throws AssertionError {
     super(actual, message);
     this.validationStrategy = getValidationStrategyFromType();
     this.actualContent = validateAndRead();
   }
 
-  public AbstractReadableAssert(ACTUAL actual, String message, ValidationStrategy strategy) throws AssertionError {
+  AbstractReadableCheck(ACTUAL actual, String message, ValidationStrategy strategy) throws AssertionError {
     super(actual, message);
     this.validationStrategy = strategy;
     this.actualContent = validateAndRead();
   }
 
-  public AbstractReadableAssert hasSameContentAs(InputStream expected) throws AssertionError {
+  AbstractReadableCheck hasSameContentAs(InputStream expected) throws AssertionError {
     if(!IoUtil.contentEquals(new ByteArrayInputStream(getActualContent()), expected)){
       throwAssertionErrorWithCustomMessage("InputStreams are NOT exactly the same");
     }
     return self;
   }
 
-  public AbstractReadableAssert hasNotSameContentAs(InputStream expected) throws AssertionError {
+  AbstractReadableCheck hasNotSameContentAs(InputStream expected) throws AssertionError {
     if(IoUtil.contentEquals(new ByteArrayInputStream(getActualContent()), expected)){
       throwAssertionErrorWithCustomMessage("InputStreams are exactly the same");
     }

src/main/java/com/yanimetaxas/realitycheck/BooleanCheck.java

@@ -0,0 +1,30 @@
+package com.yanimetaxas.realitycheck;
+
+/**
+ * @author yanimetaxas
+ * @since 18-Feb-18
+ */
+public final class BooleanCheck extends AbstractCheck<BooleanCheck, Boolean> {
+
+  BooleanCheck(Boolean aBoolean) {
+    super(aBoolean, null);
+  }
+
+  BooleanCheck(Boolean aBoolean, String customMessage) {
+    super(aBoolean, customMessage);
+  }
+
+  public BooleanCheck isTrue() throws AssertionError {
+    if(!actual) {
+      throwAssertionErrorWithCustomMessage("Is false");
+    }
+    return self;
+  }
+
+  public BooleanCheck isFalse() throws AssertionError {
+    if(actual) {
+      throwAssertionErrorWithCustomMessage("Is true");
+    }
+    return self;
+  }
+}

src/main/java/com/yanimetaxas/realitycheck/asserter/Assertable.java src/main/java/com/yanimetaxas/realitycheck/Checkable.java

@@ -1,9 +1,9 @@
-package com.yanimetaxas.realitycheck.asserter;
+package com.yanimetaxas.realitycheck;
 
 /**
  * @author yanimetaxas
  */
-public interface Assertable<SELF extends Assertable<SELF, ACTUAL>, ACTUAL> {
+interface Checkable<SELF extends Checkable<SELF, ACTUAL>, ACTUAL> {
 
   SELF isNull();
 

src/main/java/com/yanimetaxas/realitycheck/CsvCheck.java

@@ -0,0 +1,39 @@
+package com.yanimetaxas.realitycheck;
+
+import com.yanimetaxas.realitycheck.exception.ValidationException;
+import com.yanimetaxas.realitycheck.strategy.CsvValidationStrategy;
+import com.yanimetaxas.realitycheck.util.IoUtil;
+import java.io.ByteArrayInputStream;
+
+/**
+ * @author yanimetaxas
+ */
+public final class CsvCheck extends
+    AbstractReadableCheck<CsvCheck, String, CsvValidationStrategy> {
+
+  CsvCheck(String csv, String message) throws AssertionError {
+    super(csv, message);
+  }
+
+  CsvCheck hasSameContentAs(String expected) throws AssertionError {
+    return (CsvCheck) super.hasSameContentAs(new ByteArrayInputStream(expected.getBytes()));
+  }
+
+  public CsvCheck hasNotSameContentAs(String expected) throws AssertionError {
+    return (CsvCheck) super.hasNotSameContentAs(new ByteArrayInputStream(expected.getBytes()));
+  }
+
+  public CsvCheck headerHasNoDigits() throws AssertionError {
+    try {
+      String headers = IoUtil.readFirstLine(getActualContent());
+      for(String header: headers.split(",")) {
+        if (header.matches("[0-9]+")) {
+          throw new ValidationException("Header has digits");
+        }
+      }
+    } catch (Exception e) {
+      throw new AssertionError(e);
+    }
+    return this;
+  }
+}

src/main/java/com/yanimetaxas/realitycheck/CsvFileCheck.java

@@ -0,0 +1,28 @@
+package com.yanimetaxas.realitycheck;
+
+import com.yanimetaxas.realitycheck.strategy.CsvFileValidationStrategy;
+import com.yanimetaxas.realitycheck.strategy.CsvFilenameValidationStrategy;
+import com.yanimetaxas.realitycheck.util.IoUtil;
+import java.io.File;
+
+/**
+ * @author yanimetaxas
+ */
+public class CsvFileCheck extends FileCheck {
+
+  private CsvCheck csvCheck;
+
+  CsvFileCheck(String filepath, String message) throws AssertionError {
+    super(IoUtil.toFile(filepath), message, new CsvFilenameValidationStrategy(filepath));
+  }
+
+  CsvFileCheck(File csvFile, String message) throws AssertionError {
+    super(csvFile, message, new CsvFileValidationStrategy(csvFile));
+    csvCheck = new CsvCheck(new String(getActualContent()), message);
+  }
+
+  public CsvCheck headerHasNoDigits() throws AssertionError {
+    return csvCheck.headerHasNoDigits();
+  }
+
+}

src/main/java/com/yanimetaxas/realitycheck/CsvResourceCheck.java

@@ -0,0 +1,19 @@
+package com.yanimetaxas.realitycheck;
+
+import com.yanimetaxas.realitycheck.util.IoUtil;
+import java.io.File;
+
+/**
+ * @author yanimetaxas
+ * @since 17-Feb-18
+ */
+public final class CsvResourceCheck extends CsvFileCheck {
+
+  CsvResourceCheck(String filename, String message) throws AssertionError {
+    super(IoUtil.loadResource(filename), message);
+  }
+
+  CsvResourceCheck(File file, String message) throws AssertionError {
+    super(file, message);
+  }
+}

src/main/java/com/yanimetaxas/realitycheck/CustomObjectCheck.java

@@ -0,0 +1,15 @@
+package com.yanimetaxas.realitycheck;
+
+import com.yanimetaxas.realitycheck.custom.CustomObject;
+import com.yanimetaxas.realitycheck.exception.ValidationException;
+
+/**
+ * @author yanimetaxas
+ * @since 18-Feb-18
+ */
+public final class CustomObjectCheck extends AbstractCheck<CustomObjectCheck, CustomObject> {
+
+  public CustomObjectCheck(CustomObject customObject) throws ValidationException {
+    super(customObject, null);
+  }
+}

src/main/java/com/yanimetaxas/realitycheck/CustomReadableObjectCheck.java

@@ -0,0 +1,16 @@
+package com.yanimetaxas.realitycheck;
+
+import com.yanimetaxas.realitycheck.custom.CustomReadableObject;
+import com.yanimetaxas.realitycheck.exception.ValidationException;
+import com.yanimetaxas.realitycheck.strategy.CustomReadableObjectValidationStrategy;
+
+/**
+ * @author yanimetaxas
+ */
+public final class CustomReadableObjectCheck extends
+    AbstractReadableCheck<CustomReadableObjectCheck, CustomReadableObject, CustomReadableObjectValidationStrategy> {
+
+  public CustomReadableObjectCheck(CustomReadableObject customReadableObject) throws ValidationException {
+    super(customReadableObject, null);
+  }
+}

src/main/java/com/yanimetaxas/realitycheck/asserter/FileAssert.java src/main/java/com/yanimetaxas/realitycheck/FileCheck.java

@@ -1,87 +1,86 @@
-package com.yanimetaxas.realitycheck.asserter;
+package com.yanimetaxas.realitycheck;
 
-import com.yanimetaxas.realitycheck.strategy.validation.FileValidationStrategy;
-import com.yanimetaxas.realitycheck.strategy.validation.FilepathValidationStrategy;
-import com.yanimetaxas.realitycheck.strategy.validation.ValidationStrategy;
+import com.yanimetaxas.realitycheck.strategy.FileValidationStrategy;
+import com.yanimetaxas.realitycheck.strategy.FilepathValidationStrategy;
+import com.yanimetaxas.realitycheck.strategy.ValidationStrategy;
 import com.yanimetaxas.realitycheck.util.IoUtil;
 import java.io.ByteArrayInputStream;
 import java.io.File;
 
 /**
  * @author yanimetaxas
  */
-public class FileAssert extends AbstractReadableAssert<FileAssert, File, FileValidationStrategy> {
+public class FileCheck extends AbstractReadableCheck<FileCheck, File, FileValidationStrategy> {
 
-
-  public FileAssert(String filepath, String message) throws AssertionError {
+  FileCheck(String filepath, String message) throws AssertionError {
     super(IoUtil.toFile(filepath), message, new FilepathValidationStrategy(filepath));
   }
 
-  public FileAssert(File file, String message) throws AssertionError {
+  FileCheck(File file, String message) throws AssertionError {
     super(file, message);
   }
 
-  public FileAssert(File file, String message, ValidationStrategy strategy) throws AssertionError {
+  FileCheck(File file, String message, ValidationStrategy strategy) throws AssertionError {
     super(file, message, strategy);
   }
 
-  public FileAssert exists() {
+  public FileCheck exists() {
     if (!getActual().exists()) {
       throw new AssertionError("File " + actual.getName() + " doesn't exist");
     }
     return self;
   }
 
-  public FileAssert doesNotExist() {
+  public FileCheck doesNotExist() {
     if (getActual().exists()) {
       throw new AssertionError("File " + actual.getName() + " exists");
     }
     return self;
   }
 
-  public FileAssert isDirectory() {
+  public FileCheck isDirectory() {
     if (!getActual().isDirectory()) {
       throw new AssertionError("File " + actual.getName() + " is NOT directory");
     }
     return self;
   }
 
-  public FileAssert isNotDirectory() {
+  public FileCheck isNotDirectory() {
     if (getActual().isDirectory()) {
       throw new AssertionError("File " + actual.getName() + " is directory");
     }
     return self;
   }
 
-  public FileAssert isHidden() {
+  public FileCheck isHidden() {
     if (!getActual().isHidden()) {
       throw new AssertionError("File " + actual.getName() + " is NOT hidden");
     }
     return self;
   }
 
-  public FileAssert isNotHidden() {
+  public FileCheck isNotHidden() {
     if (getActual().isHidden()) {
       throw new AssertionError("File " + actual.getName() + " is hidden");
     }
     return self;
   }
 
-  public FileAssert hasSameContentAs(String filepath) throws AssertionError {
+  public FileCheck hasSameContentAs(String filepath) throws AssertionError {
     return hasSameContentAs(IoUtil.toFile(filepath));
   }
 
-  public FileAssert hasSameContentAs(File file) throws AssertionError {
-    return (FileAssert) super
+  public FileCheck hasSameContentAs(File file) throws AssertionError {
+    return (FileCheck) super
         .hasSameContentAs(new ByteArrayInputStream(IoUtil.readFile(file.getAbsolutePath())));
   }
 
-  public FileAssert hasNotSameContentAs(File file) throws AssertionError {
-    return (FileAssert) super
+  public FileCheck hasNotSameContentAs(File file) throws AssertionError {
+    return (FileCheck) super
         .hasNotSameContentAs(new ByteArrayInputStream(IoUtil.readFile(file.getAbsolutePath())));
   }
 
-  public FileAssert hasNotSameContentAs(String filepath) throws AssertionError {
+  public FileCheck hasNotSameContentAs(String filepath) throws AssertionError {
     return hasNotSameContentAs(IoUtil.toFile(filepath));
   }
 }