| /* |
| * Copyright 2015-2016 IBM Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package whisk.core.entity.test |
| |
| import java.util.Base64 |
| |
| import scala.BigInt |
| import scala.Vector |
| import scala.concurrent.duration.DurationInt |
| import scala.language.postfixOps |
| import scala.language.reflectiveCalls |
| import scala.util.Try |
| |
| import org.junit.runner.RunWith |
| import org.scalatest.BeforeAndAfter |
| import org.scalatest.FlatSpec |
| import org.scalatest.Matchers |
| import org.scalatest.junit.JUnitRunner |
| |
| import spray.json.DefaultJsonProtocol._ |
| import spray.json._ |
| import whisk.core.entity.ActionLimits |
| import whisk.core.entity.ActivationId |
| import whisk.core.entity.AuthKey |
| import whisk.core.entity.DocId |
| import whisk.core.entity.DocInfo |
| import whisk.core.entity.DocRevision |
| import whisk.core.entity.EntityName |
| import whisk.core.entity.Exec |
| import whisk.core.entity.LogLimit |
| import whisk.core.entity.MemoryLimit |
| import whisk.core.entity.EntityPath |
| import whisk.core.entity.Parameters |
| import whisk.core.entity.Secret |
| import whisk.core.entity.SemVer |
| import whisk.core.entity.TimeLimit |
| import whisk.core.entity.UUID |
| import whisk.core.entity.size.SizeInt |
| |
| @RunWith(classOf[JUnitRunner]) |
| class SchemaTests extends FlatSpec with BeforeAndAfter with Matchers { |
| |
| behavior of "AuthKey" |
| |
| it should "accept well formed keys" in { |
| val uuid = UUID() |
| val secret = Secret() |
| Seq(s"$uuid:$secret", s" $uuid: $secret", s"$uuid:$secret ", s" $uuid : $secret ").foreach { i => |
| val k = AuthKey(i) |
| assert(k.uuid == uuid) |
| assert(k.key == secret) |
| } |
| } |
| |
| it should "reject malformed ids" in { |
| Seq(null, "", " ", ":", " : ", " :", ": ", "a:b").foreach { i => |
| intercept[IllegalArgumentException] { |
| AuthKey(i) |
| } |
| } |
| } |
| |
| behavior of "DocInfo" |
| |
| it should "accept well formed doc info" in { |
| Seq("a", " a", "a ").foreach { i => |
| val d = DocInfo(i) |
| assert(d.id() == i.trim) |
| } |
| } |
| |
| it should "accept any string as doc revision" in { |
| Seq("a", " a", "a ", "", null).foreach { i => |
| val d = DocRevision(i) |
| assert(d.rev == (if (i != null) i.trim else null)) |
| } |
| |
| DocRevision.serdes.read(JsNull) shouldBe DocRevision() |
| DocRevision.serdes.read(JsString("")) shouldBe DocRevision("") |
| DocRevision.serdes.read(JsString("a")) shouldBe DocRevision("a") |
| DocRevision.serdes.read(JsString(" a")) shouldBe DocRevision("a") |
| DocRevision.serdes.read(JsString("a ")) shouldBe DocRevision("a") |
| intercept[DeserializationException] { |
| DocRevision.serdes.read(JsNumber(1)) |
| } |
| } |
| |
| it should "reject malformed doc info" in { |
| Seq(null, "", " ").foreach { i => |
| intercept[IllegalArgumentException] { |
| DocInfo(i) |
| } |
| } |
| } |
| |
| it should "reject malformed doc ids" in { |
| Seq(null, "", " ").foreach { i => |
| intercept[IllegalArgumentException] { |
| DocId(i) |
| } |
| } |
| } |
| |
| behavior of "Namespace" |
| |
| it should "accept well formed paths" in { |
| val paths = Seq("/a", "//a", "//a//", "//a//b//c", "//a//b/c//", "a", "a/b", "a/b/", "a@b.c", "a@b.c/", "a@b.c/d", "_a/", "_ _", "a/b/c") |
| val expected = Seq("a", "a", "a", "a/b/c", "a/b/c", "a", "a/b", "a/b", "a@b.c", "a@b.c", "a@b.c/d", "_a", "_ _", "a/b/c") |
| val spaces = paths.zip(expected).foreach { p => |
| assert(EntityPath(p._1).namespace == p._2) |
| } |
| } |
| |
| it should "reject malformed paths" in { |
| val paths = Seq(null, "", " ", "a/ ", "a/b/c ", " xxx", "xxx ", " xxx", "xxx/ ", "/", " /", "/ ", "//", "///", " / / / ", "a/b/ c", "a/ /b", " a/ b") |
| paths.foreach { p => |
| val thrown = intercept[IllegalArgumentException] { |
| EntityPath(p) |
| } |
| } |
| } |
| |
| behavior of "EntityName" |
| |
| it should "accept well formed names" in { |
| val paths = Seq("a", "a b", "a@b.c", "_a", "_", "_ _", "a0", "a 0", "a.0", "a@@", "0", "0.0", "0.0.0", "0a", "0.a") |
| val spaces = paths.foreach { n => |
| assert(EntityName(n).toString == n) |
| } |
| } |
| |
| it should "reject malformed names" in { |
| val paths = Seq(null, "", " ", " xxx", "xxx ", "/", " /", "/ ", "0 ", "_ ", "a ", "a \t", "a\n") |
| paths.foreach { p => |
| val thrown = intercept[IllegalArgumentException] { |
| EntityName(p) |
| } |
| } |
| } |
| |
| behavior of "SemVer" |
| |
| it should "parse semantic versions" in { |
| val semvers = Seq("0.0.1", "1", "1.2", "1.2.3.").map { SemVer(_) } |
| assert(semvers(0) == SemVer(0, 0, 1) && semvers(0).toString == "0.0.1") |
| assert(semvers(1) == SemVer(1, 0, 0) && semvers(1).toString == "1.0.0") |
| assert(semvers(2) == SemVer(1, 2, 0) && semvers(2).toString == "1.2.0") |
| assert(semvers(3) == SemVer(1, 2, 3) && semvers(3).toString == "1.2.3") |
| |
| } |
| |
| it should "permit leading zeros but strip them away" in { |
| val semvers = Seq("0.0.01", "01", "01.02", "01.02.003.").map { SemVer(_) } |
| assert(semvers(0) == SemVer(0, 0, 1)) |
| assert(semvers(1) == SemVer(1, 0, 0)) |
| assert(semvers(2) == SemVer(1, 2, 0)) |
| assert(semvers(3) == SemVer(1, 2, 3)) |
| } |
| |
| it should "reject malformed semantic version" in { |
| val semvers = Seq("0", "0.0.0", "00.00.00", ".1", "-1", "0.-1.0", "0.0.-1", "xyz", "", null) |
| semvers.foreach { v => |
| val thrown = intercept[IllegalArgumentException] { |
| SemVer(v) |
| } |
| assert(thrown.getMessage.contains("bad semantic version")) |
| } |
| } |
| |
| it should "reject negative values" in { |
| intercept[IllegalArgumentException] { |
| SemVer(-1, 0, 0) |
| } |
| intercept[IllegalArgumentException] { |
| SemVer(0, -1, 0) |
| } |
| intercept[IllegalArgumentException] { |
| SemVer(0, 0, -1) |
| } |
| intercept[IllegalArgumentException] { |
| SemVer(0, 0, 0) |
| } |
| } |
| |
| behavior of "Exec" |
| |
| it should "properly deserialize and reserialize JSON" in { |
| val b64Body = """ZnVuY3Rpb24gbWFpbihhcmdzKSB7IHJldHVybiBhcmdzOyB9Cg==""" |
| |
| val json = Seq[JsObject]( |
| JsObject("kind" -> "nodejs".toJson, "code" -> "js1".toJson, "binary" -> false.toJson), |
| JsObject("kind" -> "nodejs".toJson, "code" -> "js2".toJson, "binary" -> false.toJson, "foo" -> "bar".toJson), |
| JsObject("kind" -> "swift".toJson, "code" -> "swift1".toJson, "binary" -> false.toJson), |
| JsObject("kind" -> "nodejs".toJson, "code" -> b64Body.toJson, "binary" -> true.toJson)) |
| |
| val execs = json.map { e => Exec.serdes.read(e) } |
| |
| assert(execs(0) == Exec.js("js1") && json(0).compactPrint == Exec.js("js1").toString) |
| assert(execs(1) == Exec.js("js2") && json(1).compactPrint != Exec.js("js2").toString) // ignores unknown properties |
| assert(execs(2) == Exec.swift("swift1") && json(2).compactPrint == Exec.swift("swift1").toString) |
| assert(execs(3) == Exec.js(b64Body) && json(3).compactPrint == Exec.js(b64Body).toString) |
| } |
| |
| it should "properly deserialize and reserialize JSON blackbox" in { |
| val b64 = Base64.getEncoder() |
| val contents = b64.encodeToString("tarball".getBytes) |
| val json = Seq[JsObject]( |
| JsObject("kind" -> "blackbox".toJson, "image" -> "container1".toJson, "binary" -> false.toJson), |
| JsObject("kind" -> "blackbox".toJson, "image" -> "container1".toJson, "binary" -> true.toJson, "code" -> contents.toJson)) |
| |
| val execs = json.map { e => Exec.serdes.read(e) } |
| |
| assert(execs(0) == Exec.bb("container1") && json(0).compactPrint == Exec.bb("container1").toString) |
| assert(execs(1) == Exec.bb("container1", contents) && json(1).compactPrint == Exec.bb("container1", contents).toString) |
| assert(execs(0) == Exec.serdes.read(JsObject("kind" -> "blackbox".toJson, "image" -> "container1".toJson, "binary" -> false.toJson, "code" -> " ".toJson))) |
| assert(execs(0) == Exec.serdes.read(JsObject("kind" -> "blackbox".toJson, "image" -> "container1".toJson, "binary" -> false.toJson, "code" -> "".toJson))) |
| } |
| |
| it should "reject malformed JSON" in { |
| val b64 = Base64.getEncoder() |
| val contents = b64.encodeToString("tarball".getBytes) |
| |
| val execs = Seq[JsValue]( |
| null, |
| JsObject(), |
| JsNull, |
| JsObject("init" -> "zipfile".toJson), |
| JsObject("kind" -> "nodejs".toJson, "code" -> JsNumber(42)), |
| JsObject("kind" -> "nodejs".toJson, "init" -> "zipfile".toJson), |
| JsObject("kind" -> "turbopascal".toJson, "code" -> "BEGIN1".toJson), |
| JsObject("kind" -> "blackbox".toJson, "code" -> "js".toJson), |
| JsObject("kind" -> "swift".toJson, "swiftcode" -> "swift".toJson)) |
| |
| execs.foreach { e => |
| withClue(if (e != null) e else "null") { |
| val thrown = intercept[Throwable] { |
| Exec.serdes.read(e) |
| } |
| thrown match { |
| case _: DeserializationException => |
| case _: IllegalArgumentException => |
| case t => assert(false, "Unexpected exception:" + t) |
| } |
| } |
| } |
| } |
| |
| it should "reject null code/image arguments" in { |
| intercept[IllegalArgumentException] { |
| Exec.serdes.read(null) |
| } |
| intercept[DeserializationException] { |
| Exec.serdes.read("{}" parseJson) |
| } |
| intercept[DeserializationException] { |
| Exec.serdes.read(JsString("")) |
| } |
| } |
| |
| it should "serialize to json" in { |
| val execs = Seq(Exec.bb("container"), Exec.js("js"), Exec.js("js"), Exec.swift("swft")).map { _.toString } |
| assert(execs(0) == JsObject("kind" -> "blackbox".toJson, "image" -> "container".toJson, "binary" -> false.toJson).compactPrint) |
| assert(execs(1) == JsObject("kind" -> "nodejs".toJson, "code" -> "js".toJson, "binary" -> false.toJson).compactPrint) |
| assert(execs(2) == JsObject("kind" -> "nodejs".toJson, "code" -> "js".toJson, "binary" -> false.toJson).compactPrint) |
| assert(execs(3) == JsObject("kind" -> "swift".toJson, "code" -> "swft".toJson, "binary" -> false.toJson).compactPrint) |
| } |
| |
| behavior of "Parameter" |
| it should "properly deserialize and reserialize JSON" in { |
| val json = Seq[JsValue]( |
| JsArray(JsObject("key" -> "k".toJson, "value" -> "v".toJson)), |
| JsArray(JsObject("key" -> "k".toJson, "value" -> "v".toJson, "foo" -> "bar".toJson)), |
| JsArray(JsObject("key" -> "k".toJson, "value" -> 3.toJson)), |
| JsArray(JsObject("key" -> "k".toJson, "value" -> Vector(false, true).toJson))) |
| val params = json.map { p => Parameters.serdes.read(p) } |
| assert(params(0) == Parameters("k", "v")) |
| assert(params(1) == Parameters("k", "v")) |
| assert(params(0).toString == json(0).compactPrint) |
| assert(params(1).toString == json(0).compactPrint) // drops unknown prop "foo" |
| assert(params(1).toString != json(1).compactPrint) // drops unknown prop "foo" |
| assert(params(2).toString == json(2).compactPrint) // drops unknown prop "foo" |
| assert(params(3).toString == json(3).compactPrint) // drops unknown prop "foo" |
| } |
| |
| it should "reject malformed JSON" in { |
| val params = Seq[JsValue]( |
| null, |
| JsObject(), |
| JsObject("key" -> "k".toJson), |
| JsObject("value" -> "v".toJson), |
| JsObject("key" -> JsNull, "value" -> "v".toJson), |
| JsObject("key" -> "k".toJson, ("value" -> JsNull)), |
| JsObject("key" -> JsNull, "value" -> JsNull), |
| JsObject("KEY" -> "k".toJson, "VALUE" -> "v".toJson), |
| JsObject("key" -> "k".toJson, "value" -> 0.toJson)) |
| |
| params.foreach { p => |
| val thrown = intercept[DeserializationException] { |
| Parameters.serdes.read(p) |
| } |
| } |
| } |
| |
| it should "reject undefined key" in { |
| intercept[DeserializationException] { |
| Parameters.serdes.read(null: JsValue) |
| } |
| intercept[IllegalArgumentException] { |
| Parameters(null, null: String) |
| } |
| intercept[IllegalArgumentException] { |
| Parameters("", null: JsValue) |
| } |
| intercept[IllegalArgumentException] { |
| Parameters(" ", null: String) |
| } |
| intercept[IllegalArgumentException] { |
| Parameters(null, "") |
| } |
| intercept[IllegalArgumentException] { |
| Parameters(null, " ") |
| } |
| intercept[IllegalArgumentException] { |
| Parameters(null) |
| } |
| } |
| |
| it should "serialize to json" in { |
| assert(Parameters("k", null: String).toString == JsArray(JsObject("key" -> "k".toJson, "value" -> JsNull)).compactPrint) |
| assert(Parameters("k", "").toString == JsArray(JsObject("key" -> "k".toJson, "value" -> "".toJson)).compactPrint) |
| assert(Parameters("k", " ").toString == JsArray(JsObject("key" -> "k".toJson, "value" -> "".toJson)).compactPrint) |
| assert(Parameters("k", "v").toString == JsArray(JsObject("key" -> "k".toJson, "value" -> "v".toJson)).compactPrint) |
| } |
| |
| behavior of "ActionLimits" |
| |
| it should "properly deserialize JSON" in { |
| val json = Seq[JsValue]( |
| JsObject("timeout" -> TimeLimit.STD_DURATION.toMillis.toInt.toJson, "memory" -> MemoryLimit.STD_MEMORY.toMB.toInt.toJson, "logs" -> LogLimit.STD_LOGSIZE.toMB.toInt.toJson), |
| JsObject("timeout" -> TimeLimit.STD_DURATION.toMillis.toInt.toJson, "memory" -> MemoryLimit.STD_MEMORY.toMB.toInt.toJson, "logs" -> LogLimit.STD_LOGSIZE.toMB.toInt.toJson, "foo" -> "bar".toJson), |
| JsObject("timeout" -> TimeLimit.STD_DURATION.toMillis.toInt.toJson, "memory" -> MemoryLimit.STD_MEMORY.toMB.toInt.toJson)) |
| val limits = json.map(ActionLimits.serdes.read) |
| assert(limits(0) == ActionLimits()) |
| assert(limits(1) == ActionLimits()) |
| assert(limits(2) == ActionLimits()) |
| assert(limits(0).toJson == json(0)) |
| assert(limits(1).toJson == json(0)) // drops unknown prop "foo" |
| assert(limits(1).toJson != json(1)) // drops unknown prop "foo" |
| } |
| |
| it should "reject malformed JSON" in { |
| val limits = Seq[JsValue]( |
| null, |
| JsObject(), |
| JsNull, |
| JsObject("timeout" -> TimeLimit.STD_DURATION.toMillis.toInt.toJson), |
| JsObject("memory" -> MemoryLimit.STD_MEMORY.toMB.toInt.toJson), |
| JsObject("logs" -> (LogLimit.STD_LOGSIZE.toMB.toInt + 1).toJson), |
| JsObject("TIMEOUT" -> TimeLimit.STD_DURATION.toMillis.toInt.toJson, "MEMORY" -> MemoryLimit.STD_MEMORY.toMB.toInt.toJson), |
| JsObject("timeout" -> (TimeLimit.STD_DURATION.toMillis.toDouble + .01).toJson, "memory" -> (MemoryLimit.STD_MEMORY.toMB.toDouble + .01).toJson), |
| JsObject("timeout" -> null, "memory" -> null), |
| JsObject("timeout" -> JsNull, "memory" -> JsNull), |
| JsObject("timeout" -> TimeLimit.STD_DURATION.toMillis.toString.toJson, "memory" -> MemoryLimit.STD_MEMORY.toMB.toInt.toString.toJson)) |
| |
| limits.foreach { p => |
| val thrown = intercept[DeserializationException] { |
| ActionLimits.serdes.read(p) |
| } |
| } |
| } |
| |
| it should "pass the correct error message through" in { |
| val serdes = Seq(TimeLimit.serdes, MemoryLimit.serdes, LogLimit.serdes) |
| |
| serdes foreach { s => |
| withClue(s"serializer $s") { |
| if (s != LogLimit.serdes) { |
| val lb = the[DeserializationException] thrownBy s.read(JsNumber(0)) |
| lb.getMessage should include("below allowed threshold") |
| } else { |
| val lb = the[DeserializationException] thrownBy s.read(JsNumber(-1)) |
| lb.getMessage should include("a negative size of an object is not allowed") |
| } |
| |
| val ub = the[DeserializationException] thrownBy s.read(JsNumber(Int.MaxValue)) |
| ub.getMessage should include("exceeds allowed threshold") |
| |
| val int = the[DeserializationException] thrownBy s.read(JsNumber(2.5)) |
| int.getMessage should include("limit must be whole number") |
| } |
| } |
| } |
| |
| it should "reject bad limit values" in { |
| an[IllegalArgumentException] should be thrownBy ActionLimits(TimeLimit(TimeLimit.MIN_DURATION - 1.millisecond), MemoryLimit(), LogLimit()) |
| an[IllegalArgumentException] should be thrownBy ActionLimits(TimeLimit(), MemoryLimit(MemoryLimit.MIN_MEMORY - 1.B), LogLimit()) |
| an[IllegalArgumentException] should be thrownBy ActionLimits(TimeLimit(), MemoryLimit(), LogLimit(LogLimit.MIN_LOGSIZE - 1.B)) |
| |
| an[IllegalArgumentException] should be thrownBy ActionLimits(TimeLimit(TimeLimit.MAX_DURATION + 1.millisecond), MemoryLimit(), LogLimit()) |
| an[IllegalArgumentException] should be thrownBy ActionLimits(TimeLimit(), MemoryLimit(MemoryLimit.MAX_MEMORY + 1.B), LogLimit()) |
| an[IllegalArgumentException] should be thrownBy ActionLimits(TimeLimit(), MemoryLimit(), LogLimit(LogLimit.MAX_LOGSIZE + 1.B)) |
| } |
| |
| it should "parse activation id as uuid" in { |
| val id = "213174381920559471141441e1111111" |
| val aid = ActivationId.unapply(id) |
| assert(aid.isDefined) |
| assert(aid.get.toString == id) |
| } |
| |
| it should "parse activation id as uuid when made up of no numbers" in { |
| val id = "a" * 32 |
| val aid = ActivationId.unapply(id) |
| assert(aid.isDefined) |
| assert(aid.get.toString == id) |
| } |
| |
| it should "parse activation id as uuid when made up of no letters" in { |
| val id = "1" * 32 |
| val aid = ActivationId.unapply(id) |
| assert(aid.isDefined) |
| assert(aid.get.toString == id) |
| } |
| |
| it should "parse an activation id as uuid when it is a number" in { |
| val id = "1" * 32 |
| val aid = Try { ActivationId.serdes.read(BigInt(id).toJson) } |
| assert(aid.isSuccess) |
| assert(aid.get.toString == id) |
| } |
| |
| it should "not parse invalid activation id" in { |
| val id = "213174381920559471141441e111111z" |
| assert(ActivationId.unapply(id).isEmpty) |
| assert(Try { ActivationId.serdes.read(JsString(id)) }.failed.get.getMessage.contains("malformed")) |
| } |
| |
| it should "not parse activation id if longer than uuid" in { |
| val id = "213174381920559471141441e1111111abc" |
| assert(ActivationId.unapply(id).isEmpty) |
| assert(Try { ActivationId.serdes.read(JsString(id)) }.failed.get.getMessage.contains("too long")) |
| } |
| |
| it should "not parse activation id if shorter than uuid" in { |
| val id = "213174381920559471141441e1" |
| assert(ActivationId.unapply(id).isEmpty) |
| assert(Try { ActivationId.serdes.read(JsString(id)) }.failed.get.getMessage.contains("too short")) |
| } |
| } |
