Response bad request 400 for incorrect param types Char, Boolean, Byte, Short, Int, Long, Float, Double (#681)

Author: ungit

src/main/scala/xitrum/scope/request/ParamAccess.scala

@@ -4,7 +4,7 @@ import scala.reflect.runtime.universe._
 import io.netty.handler.codec.http.multipart.FileUpload
 
 import xitrum.Action
-import xitrum.exception.MissingParam
+import xitrum.exception.{InvalidInput, MissingParam}
 import xitrum.util.DefaultsTo
 
 /**
@@ -43,7 +43,7 @@ trait ParamAccess {
  } else {
  coll.get(key) match {
  case None => throw new MissingParam(key)
- case Some(values) => convertTextParam[T](values.head)
+ case Some(values) => convertTextParam[T](key, values.head)
  }
  }
  }
@@ -55,7 +55,7 @@ trait ParamAccess {
  if (typeOf[T] <:< TYPE_FILE_UPLOAD) {
  bodyFileParams.get(key).map(_.head.asInstanceOf[T])
  } else {
- coll.get(key).map(values => convertTextParam[T](values.head))
+ coll.get(key).map(values => convertTextParam[T](key, values.head))
  }
  }
 
@@ -71,17 +71,17 @@ trait ParamAccess {
  } else {
  coll.get(key) match {
  case None => Seq.empty
- case Some(values) => values.map(convertTextParam[T])
+ case Some(values) => values.map(convertTextParam[T](key, _))
  }
  }
  }
 
  //----------------------------------------------------------------------------
 
  /** Applications may override this method to convert to more types. */
- def convertTextParam[T: TypeTag](value: String): T = {
+ def convertTextParam[T: TypeTag](key: String, value: String): T = {
  val t = typeOf[T]
- val any: Any =
+ scala.util.Try[Any] {
  if (t <:< TYPE_STRING) value
  else if (t <:< TYPE_CHAR) value(0)
  else if (t <:< TYPE_BOOLEAN) value.toBoolean
@@ -91,7 +91,11 @@ trait ParamAccess {
  else if (t <:< TYPE_LONG) value.toLong
  else if (t <:< TYPE_FLOAT) value.toFloat
  else if (t <:< TYPE_DOUBLE) value.toDouble
- else throw new Exception("convertTextParam cannot covert " + value + " to " + t)
- any.asInstanceOf[T]
+ else throw new Exception(s"convertTextParam $key cannot convert $value to $t")
+ }.recoverWith {
+ case _: StringIndexOutOfBoundsException |
+ _: IllegalArgumentException =>
+ scala.util.Failure(new InvalidInput(s"""Cannot convert "$value" of param "$key" to $t"""))
+ }.get.asInstanceOf[T]
  }
 }

src/test/scala/xitrum/params/ParamsTest.scala

@@ -48,6 +48,17 @@ class ParamsPayloadTestAction extends Action with SkipCsrfCheck {
  }
 }
 
+@GET("test/params/validation")
+class ParamsValidationTestAction extends Action with SkipCsrfCheck {
+ def execute() {
+ param[Char]("keyChar")
+ param[Int]("keyInt")
+ param[Boolean]("keyBoolean")
+ 
+ respondText("Ok")
+ }
+}
+
 class ParamsTest extends FlatSpec with Matchers with BeforeAndAfter with Log {
  private implicit val formats = Serialization.formats(NoTypeHints)
  private val base = "http://127.0.0.1:8000/my_site"
@@ -107,6 +118,50 @@ class ParamsTest extends FlatSpec with Matchers with BeforeAndAfter with Log {
  shouldEqual(response, ParamsPayloadResponse(1, Seq(2, 3), "ru-RU", Some("value")))
  }
 
+ "[GET] param" should "response validation error char" in {
+ val response = client.prepareGet(s"$base/test/params/validation")
+ .addQueryParam("keyChar", "")
+ .addQueryParam("keyInt", "1")
+ .addQueryParam("keyBoolean", "true")
+ .execute().get()
+ (response.getStatusCode, response.getResponseBody) shouldEqual
+ (400, """Validation error: Cannot convert "" of param "keyChar" to Char""")
+ }
+
+ "[GET] param" should "response validation error overflow int" in {
+ val keyValue = Int.MaxValue + 1L
+ val response = client.prepareGet(s"$base/test/params/validation")
+ .addQueryParam("keyChar", "a")
+ .addQueryParam("keyInt", keyValue.toString)
+ .addQueryParam("keyBoolean", "true")
+ .execute().get()
+ (response.getStatusCode, response.getResponseBody) shouldEqual
+ (400, s"""Validation error: Cannot convert "$keyValue" of param "keyInt" to Int""")
+ }
+
+
+ "[GET] param" should "response validation error parse int" in {
+ val keyValue = "1a"
+ val response = client.prepareGet(s"$base/test/params/validation")
+ .addQueryParam("keyChar", "a")
+ .addQueryParam("keyInt", keyValue)
+ .addQueryParam("keyBoolean", "true")
+ .execute().get()
+ (response.getStatusCode, response.getResponseBody) shouldEqual
+ (400, s"""Validation error: Cannot convert "$keyValue" of param "keyInt" to Int""")
+ }
+
+ "[GET] param" should "response validation error parse boolean" in {
+ val value = "tru"
+ val response = client.prepareGet(s"$base/test/params/validation")
+ .addQueryParam("keyChar", "c")
+ .addQueryParam("keyInt", "1")
+ .addQueryParam("keyBoolean", value)
+ .execute().get()
+ (response.getStatusCode, response.getResponseBody) shouldEqual
+ (400, s"""Validation error: Cannot convert "$value" of param "keyBoolean" to Boolean""")
+ }
+
  private def shouldEqual[T](response: Response, expected: T)(implicit formats: Formats, mf: Manifest[T]) = {
  if (response.getStatusCode != 200) {
  log.warn(s"Response:\n$response")