Adding type checks to unit tests.

src/test/scala/TestValidationDsl.scala

@@ -1,4 +1,4 @@
-import com.github.vickumar1981.svalidate.Validation
+import com.github.vickumar1981.svalidate.{Validation, ValidationSuccess, ValidationFailure}
 import org.scalatest.{FlatSpec, Matchers}
 
 class TestValidationDsl extends FlatSpec with Matchers {
@@ -7,11 +7,29 @@ class TestValidationDsl extends FlatSpec with Matchers {
 
   private def checkFailure(v: Validation) = {
     v.isFailure should be(true)
+    v match {
+      case ValidationSuccess() => fail("ValidationSuccess was not equal to ValidationFailure")
+      case ValidationFailure(_) => succeed
+    }
   }
 
   private def checkSuccess(v: Validation) = {
     v should be(Validation.success)
     v.isSuccess should be(true)
+    v match {
+      case ValidationSuccess() => succeed
+      case ValidationFailure(_) => fail("ValidationFailure was not equal to ValidationSuccess")
+    }
+  }
+
+  "validate" should "return a ValidationSuccess if no implementation is defined" in {
+    val result = BlankObject().validate()
+    checkSuccess(result)
+  }
+
+  "validateWith" should "return a ValidationSuccess if no implementation is defined" in {
+    val result = BlankObject().validateWith("")
+    checkSuccess(result)
   }
 
   "validate" should "return a success if no validation errors occur" in {
@@ -29,16 +47,31 @@ class TestValidationDsl extends FlatSpec with Matchers {
   }
 
   "thenCheck" should "perform validation conditionally" in {
-    val emptyContactInfo = validPerson.copy(address = None, phone = None).validate()
-    emptyContactInfo should be(
+    val emptyPersonInfo = validPerson.copy(address = None, phone = None).validate()
+    emptyPersonInfo should be(
       Validation.fail("Address is required", "Phone # is required"))
-    checkFailure(emptyContactInfo)
+    checkFailure(emptyPersonInfo)
 
-    val emptyContactInfoOkay = validPerson.copy(
+    val emptyPersonInfoOkay = validPerson.copy(
       address = None,
       phone = None,
       hasContactInfo = false).validate()
-    emptyContactInfoOkay should be(Validation.success)
-    checkSuccess(emptyContactInfoOkay)
+    emptyPersonInfoOkay should be(Validation.success)
+    checkSuccess(emptyPersonInfoOkay)
+  }
+
+  "validateWith" should "accept a generic type parameter" in {
+    val emptyFirstName = validContactInfo.copy(firstName = "")
+    val emptyLastName = validContactInfo.copy(lastName = "")
+
+    val emptyFirstNameSuccess = emptyFirstName.validateWith(false)
+    val emptyFirstNameFailure = emptyFirstName.validateWith(true)
+    checkSuccess(emptyFirstNameSuccess)
+    checkFailure(emptyFirstNameFailure)
+
+    val emptyLastNameSuccess = emptyLastName.validateWith(false)
+    val emptyLastNameFailure = emptyLastName.validateWith(true)
+    checkSuccess(emptyLastNameSuccess)
+    checkFailure(emptyLastNameFailure)
   }
 }

src/test/scala/fixtures/TestData.scala

@@ -1,7 +1,7 @@
 package fixtures
 
 import com.github.javafaker.Faker
-import com.github.vickumar1981.svalidate.{Validatable, Validation}
+import com.github.vickumar1981.svalidate.{Validatable, ValidatableWith, Validation}
 
 import scala.util.Random
 
@@ -10,6 +10,11 @@ object TestData {
   private final val phoneNumberLength = 10
   val faker = new Faker()
 
+  case class BlankObject()
+
+  implicit object BlankObjectValidator extends Validatable[BlankObject]
+  implicit object BlankObjectValidatorWith extends ValidatableWith[BlankObject, String]
+
   def validAddress: Address = Address(
     faker.address.streetAddress,
     faker.address.city,
@@ -23,6 +28,20 @@ object TestData {
     Some(validAddress),
     Some(Random.alphanumeric.filter(_.isDigit).take(phoneNumberLength).mkString))
 
+  def validContactInfo: ContactInfo = ContactInfo(
+    faker.name.firstName,
+    faker.name.lastName)
+
+  case class ContactInfo(firstName: String, lastName: String)
+
+  implicit object ContactInfoValidator extends ValidatableWith[ContactInfo, Boolean] {
+    override def validateWith(value: ContactInfo, isRequired: Boolean): Validation =
+      if (isRequired) {
+        (value.firstName.isEmpty thenThrow "First name is required") ++
+          (value.lastName.isEmpty thenThrow "Last name is required")
+      } else { Validation.success }
+  }
+
   case class Address(street: String,
                      city: String,
                      state: String,