Play Framework/Scala example source code file (ValidationSpec.scala)

This example Play Framework source code file (ValidationSpec.scala) is included in my "Source Code Warehouse" project. The intent of this project is to help you more easily find Play Framework (and Scala) source code examples by using tags.

All credit for the original source code belongs to Play Framework; I'm just trying to make examples easier to find. (For my Scala work, see my Scala examples and tutorials.)

Play Framework tags/keywords

api, cc, data, error, form, illegalargumentexception, map, min, play, play framework, seq, some, the, toto, validate, validation

The ValidationSpec.scala Play Framework example source code

/*
 * Copyright (C) 2009-2013 Typesafe Inc. <http://www.typesafe.com>
 */
package play.api.data.validation

import org.specs2.mutable._

import play.api.data._
import play.api.data.Forms._
import play.api.data.format.Formats._
import play.api.data.validation.Constraints._

object ValidationSpec extends Specification {

  "text" should {
    "throw an IllegalArgumentException if maxLength is negative" in {
      {
        Form(
          "value" -> Forms.text(maxLength = -1)
        ).bind(Map("value" -> "hello"))
      }.must(throwAn[IllegalArgumentException])
    }

    "return a bound form with error if input is null, even if maxLength=0 " in {
      Form("value" -> Forms.text(maxLength = 0)).bind(Map("value" -> null)).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.maxLength") },
        { textData => "The mapping should fail." must equalTo("Error") }
      )
    }

    "throw an IllegalArgumentException if minLength is negative" in {
      {
        Form(
          "value" -> Forms.text(minLength = -1)
        ).bind(Map("value" -> "hello"))
      }.must(throwAn[IllegalArgumentException])
    }

    "return a bound form with error if input is null, even if minLength=0" in {
      Form("value" -> Forms.text(minLength = 0)).bind(Map("value" -> null)).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.minLength") },
        { textData => "The mapping should fail." must equalTo("Error") }
      )
    }
  }

  "nonEmptyText" should {
    "return a bound form with error if input is null" in {
      Form("value" -> nonEmptyText).bind(Map("value" -> null)).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.required") },
        { textData => "The mapping should fail." must equalTo("Error") }
      )
    }
  }

  "Constraints.pattern" should {
    "throw an IllegalArgumentException if regex is null" in {
      {
        Form(
          "value" -> Forms.text.verifying(Constraints.pattern(null, "nullRegex", "error"))
        ).bind(Map("value" -> "hello"))
      }.must(throwAn[IllegalArgumentException])
    }

    "throw an IllegalArgumentException if name is null" in {
      {
        Form(
          "value" -> Forms.text.verifying(Constraints.pattern(".*".r, null, "error"))
        ).bind(Map("value" -> "hello"))
      }.must(throwAn[IllegalArgumentException])
    }

    "throw an IllegalArgumentException if error is null" in {
      {
        Form(
          "value" -> Forms.text.verifying(pattern(".*".r, "nullRegex", null))
        ).bind(Map("value" -> "hello"))
      }.must(throwAn[IllegalArgumentException])
    }

  }

  "Email constraint" should {
    val valid = Seq(
      """"Fred Bloggs"@example.com""",
      """"Joe\\Blow"@example.com""",
      """"Abc@def"@example.com""",
      """customer/department=shipping@example.com""",
      """$A12345@example.com""",
      """!def!xyz%abc@example.com""",
      """_somename@example.com""",
      """Ken.O'Brian@company.com"""
      )
    "validate valid addresses" in {
      valid.map{ addr =>
        Form( "value" -> email ).bind( Map( "value" -> addr) ).fold(
          formWithErrors => false,
          { _  => true}
        )
      }.exists(_.unary_!) must beFalse
    }

    val invalid = Seq(
      "NotAnEmail",
      "@NotAnEmail",
      "\"\"test\blah\"\"@example.com",
      "\"test\rblah\"@example.com",
      "\"\"test\"\"blah\"\"@example.com",
      ".wooly@example.com",
      "wo..oly@example.com",
      "pootietang.@example.com",
      ".@example.com",
      "Ima Fool@example.com"
    )
    "invalidate invalid addresses" in {
      invalid.map{ addr =>
        Form( "value" -> email ).bind( Map( "value" -> addr) ).fold(
          formWithErrors => true,
          { _  => false}
        )
      }.exists(_.unary_!) must beFalse
    }
  }

  "Min and max constraint on an Int" should {
    "5 must be a valid number(1,10)" in {
      Form( "value" -> number(1,10) ).bind( Map( "value" -> "5") ).fold(
        formWithErrors => { "The mapping should not fail." must equalTo("Error") },
        { number => number must equalTo(5) }
      )
    }

    "15 must not be a valid number(1,10)" in {
      Form( "value" -> number(1,10) ).bind( Map( "value" -> "15") ).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.max") },
        { number => "The mapping should fail." must equalTo("Error") }
      )
    }
  }

  "Min and max constraint on a Long" should {
    "12345678902 must be a valid longNumber(1,10)" in {
      Form( "value" -> longNumber(1,123456789023L) ).bind( Map( "value" -> "12345678902") ).fold(
        formWithErrors => { "The mapping should not fail." must equalTo("Error") },
        { number => number must equalTo(12345678902L) }
      )
    }

    "-12345678902 must not be a valid longNumber(1,10)" in {
      Form( "value" -> longNumber(1,10) ).bind( Map( "value" -> "-12345678902") ).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.min") },
        { number => "The mapping should fail." must equalTo("Error") }
      )
    }
  }

  "Min constraint should now work on a String" should {
    "Toto must be over CC" in {
      Form( "value" -> ( nonEmptyText verifying min("CC") ) ).bind( Map( "value" -> "Toto") ).fold(
        formWithErrors => { "The mapping should not fail." must equalTo("Error") },
        { str => str must equalTo("Toto") }
      )
    }

    "AA must not be over CC" in {
      Form( "value" -> ( nonEmptyText verifying min("CC") ) ).bind( Map( "value" -> "AA") ).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.min") },
        { str => "The mapping should fail." must equalTo("Error") }
      )
    }
  }

  "Max constraint should now work on a Double" should {
    "10.2 must be under 100.1" in {
      Form( "value" -> ( of[Double] verifying max(100.1) ) ).bind( Map( "value" -> "10.2") ).fold(
        formWithErrors => { "The mapping should not fail." must equalTo("Error") },
        { number => number must equalTo(10.2) }
      )
    }

    "110.3 must not be over 100.1" in {
      Form( "value" -> ( of[Double] verifying max(100.1) ) ).bind( Map( "value" -> "110.3") ).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.max") },
        { number => "The mapping should fail." must equalTo("Error") }
      )
    }
  }

  "Min and max can now be strict" should {
    "5 must be a valid number(1,10, strict = true)" in {
      Form( "value" -> number(1,10, strict = true) ).bind( Map( "value" -> "5") ).fold(
        formWithErrors => { "The mapping should not fail." must equalTo("Error") },
        { number => number must equalTo(5) }
      )
    }

    "5 must still be a valid number(5,10)" in {
      Form( "value" -> number(5,10) ).bind( Map( "value" -> "5") ).fold(
        formWithErrors => { "The mapping should not fail." must equalTo("Error") },
        { number => number must equalTo(5) }
      )
    }

    "5 must not be a valid number(5,10, strict = true)" in {
      Form( "value" -> number(5,10, strict = true) ).bind( Map( "value" -> "5") ).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.min.strict") },
        { number => "The mapping should fail." must equalTo("Error") }
      )
    }

    "Text containing whitespace only should be rejected by nonEmptyText" in {
      Form( "value" -> nonEmptyText ).bind( Map( "value" -> " ") ).fold(
        formWithErrors => { formWithErrors.errors.head.message must equalTo("error.required") },
        { text => "The mapping should fail." must equalTo("Error") }
      )
    }
  }

  "ParameterValidator" should {
    "accept a valid value" in {
      ParameterValidator(List(Constraints.max(10)), Some(9)) must equalTo (Valid)
    }

    "refuse a value out of range" in {
      val result = Invalid(List(ValidationError("error.max", 10)))
      ParameterValidator(List(Constraints.max(10)), Some(11)) must equalTo (result)
    }

    "validate multiple values" in {
      val constraints = List(Constraints.max(10), Constraints.min(1))
      val values = Seq(Some(9), Some(0), Some(5))
      val expected = Invalid(List(ValidationError("error.min", 1)))

      ParameterValidator(constraints, values:_*) must equalTo (expected)
    }

    "validate multiple string values and multiple validation errors" in {
      val constraints = List(Constraints.maxLength(10), Constraints.minLength(1))
      val values = Seq(Some(""), Some("12345678910"), Some("valid"))
      val expected = Invalid(List(ValidationError("error.minLength", 1), ValidationError("error.maxLength", 10)))

      ParameterValidator(constraints, values:_*) must equalTo (expected)
    }
  }

}