tests/src/test/scala/actionContainers/ActionProxyContainerTests.scala - openwhisk-runtime-php - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 actionContainers

 import java.io.File
 import java.util.Base64

 import org.apache.commons.io.FileUtils
 import org.junit.runner.RunWith
 import org.scalatest.junit.JUnitRunner

 import ActionContainer.withContainer
 import common.TestUtils
 import common.WskActorSystem
 import spray.json.DefaultJsonProtocol._
 import spray.json._

 @RunWith(classOf[JUnitRunner])
 class ActionProxyContainerTests extends BasicActionRunnerTests with WskActorSystem {

   override def withActionContainer(env: Map[String, String] = Map.empty)(code: ActionContainer => Unit) = {
     withContainer("dockerskeleton", env)(code)
   }

   val codeNotReturningJson = """
            |#!/bin/sh
            |echo not a json object
         """.stripMargin.trim

   /** Standard code samples, should print 'hello' to stdout and echo the input args. */
   val stdCodeSamples = {
     val bash = """
                 |#!/bin/bash
                 |echo 'hello stdout'
                 |echo 'hello stderr' 1>&2
                 |if [[ -z $1 || $1 == '{}' ]]; then
                 |   echo '{ "msg": "Hello from bash script!" }'
                 |else
                 |   echo $1 # echo the arguments back as the result
                 |fi
             """.stripMargin.trim

     val python = """
                 |#!/usr/bin/env python
                 |from __future__ import print_function
                 |import sys
                 |print('hello stdout')
                 |print('hello stderr', file=sys.stderr)
                 |print(sys.argv[1])
             """.stripMargin.trim

     val perl = """
                 |#!/usr/bin/env perl
                 |print STDOUT "hello stdout\n";
                 |print STDERR "hello stderr\n";
                 |print $ARGV[0];
             """.stripMargin.trim

     // excluding perl as it not installed in alpine based image
     Seq(("bash", bash), ("python", python))
   }

   val stdUnicodeSamples = {
     // python 3 in base image
     val python = """
                 |#!/usr/bin/env python
                 |import json, sys
                 |j = json.loads(sys.argv[1])
                 |sep = j["delimiter"]
                 |s = sep + " ☃ " + sep
                 |print(s)
                 |print(json.dumps({"winter": s}))
             """.stripMargin.trim

     Seq(("python", python))
   }

   /** Standard code samples, should print 'hello' to stdout and echo the input args. */
   val stdEnvSamples = {
     val bash = """
                 |#!/bin/bash
                 |echo "{ \
                 |\"api_host\": \"$__OW_API_HOST\", \"api_key\": \"$__OW_API_KEY\", \
                 |\"namespace\": \"$__OW_NAMESPACE\", \"action_name\": \"$__OW_ACTION_NAME\", \
                 |\"activation_id\": \"$__OW_ACTIVATION_ID\", \"deadline\": \"$__OW_DEADLINE\" }"
             """.stripMargin.trim

     val python =
       """
                 |#!/usr/bin/env python
                 |import os
                 |
                 |print('{ "api_host": "%s", "api_key": "%s", "namespace": "%s", "action_name" : "%s", "activation_id": "%s", "deadline": "%s" }' % (
                 |  os.environ['__OW_API_HOST'], os.environ['__OW_API_KEY'],
                 |  os.environ['__OW_NAMESPACE'], os.environ['__OW_ACTION_NAME'],
                 |  os.environ['__OW_ACTIVATION_ID'], os.environ['__OW_DEADLINE']))
             """.stripMargin.trim

     val perl =
       """
                 |#!/usr/bin/env perl
                 |$a = $ENV{'__OW_API_HOST'};
                 |$b = $ENV{'__OW_API_KEY'};
                 |$c = $ENV{'__OW_NAMESPACE'};
                 |$d = $ENV{'__OW_ACTION_NAME'};
                 |$e = $ENV{'__OW_ACTIVATION_ID'};
                 |$f = $ENV{'__OW_DEADLINE'};
                 |print "{ \"api_host\": \"$a\", \"api_key\": \"$b\", \"namespace\": \"$c\", \"action_name\": \"$d\", \"activation_id\": \"$e\", \"deadline\": \"$f\" }";
             """.stripMargin.trim

     // excluding perl as it not installed in alpine based image
     Seq(("bash", bash), ("python", python))
   }

   behavior of "openwhisk/dockerskeleton"

   it should "run sample without init" in {
     val (out, err) = withActionContainer() { c =>
       val (runCode, out) = c.run(JsObject())
       runCode should be(200)
       out should be(Some(JsObject("error" -> JsString("This is a stub action. Replace it with custom logic."))))
     }

     checkStreams(out, err, {
       case (o, _) => o should include("This is a stub action")
     })
   }

   it should "run sample with 'null' init" in {
     val (out, err) = withActionContainer() { c =>
       val (initCode, _) = c.init(initPayload(null))
       initCode should be(200)

       val (runCode, out) = c.run(JsObject())
       runCode should be(200)
       out should be(Some(JsObject("error" -> JsString("This is a stub action. Replace it with custom logic."))))
     }

     checkStreams(out, err, {
       case (o, _) => o should include("This is a stub action")
     })
   }

   it should "run sample with init that does nothing" in {
     val (out, err) = withActionContainer() { c =>
       val (initCode, _) = c.init(JsObject())
       initCode should be(200)
       val (runCode, out) = c.run(JsObject())
       runCode should be(200)
       out should be(Some(JsObject("error" -> JsString("This is a stub action. Replace it with custom logic."))))
     }

     checkStreams(out, err, {
       case (o, _) => o should include("This is a stub action")
     })
   }

   it should "respond with 404 for bad run argument" in {
     val (out, err) = withActionContainer() { c =>
       val (runCode, out) = c.run(runPayload(JsString("A")))
       runCode should be(404)
     }

     checkStreams(out, err, {
       case (o, e) =>
         o shouldBe empty
         e shouldBe empty
     })
   }

   it should "fail to run a bad script" in {
     val (out, err) = withActionContainer() { c =>
       val (initCode, _) = c.init(initPayload(""))
       initCode should be(200)
       val (runCode, out) = c.run(JsNull)
       runCode should be(502)
       out should be(Some(JsObject("error" -> JsString("The action did not return a dictionary."))))
     }

     checkStreams(out, err, {
       case (o, _) => o should include("error")
     })
   }

   it should "extract and run a compatible zip exec" in {
     val zip = FileUtils.readFileToByteArray(new File(TestUtils.getTestActionFilename("blackbox.zip")))
     val contents = Base64.getEncoder.encodeToString(zip)

     val (out, err) = withActionContainer() { c =>
       val (initCode, err) =
         c.init(JsObject("value" -> JsObject("code" -> JsString(contents), "binary" -> JsBoolean(true))))
       initCode should be(200)
       val (runCode, out) = c.run(JsObject())
       runCode should be(200)
       out.get should be(JsObject("msg" -> JsString("hello zip")))
     }

     checkStreams(out, err, {
       case (o, e) =>
         o shouldBe "This is an example zip used with the docker skeleton action."
         e shouldBe empty
     })
   }

   testNotReturningJson(codeNotReturningJson, checkResultInLogs = true)
   testEcho(stdCodeSamples)
   testUnicode(stdUnicodeSamples)
   testEnv(stdEnvSamples)
 }

 trait BasicActionRunnerTests extends ActionProxyContainerTestUtils {
   def withActionContainer(env: Map[String, String] = Map.empty)(code: ActionContainer => Unit): (String, String)

   /**
    * Runs tests for actions which do not return a dictionary and confirms expected error messages.
    * @param codeNotReturningJson code to execute, should not return a JSON object
    * @param checkResultInLogs should be true iff the result of the action is expected to appear in stdout or stderr
    */
   def testNotReturningJson(codeNotReturningJson: String, checkResultInLogs: Boolean = true) = {
     it should "run and report an error for script not returning a json object" in {
       val (out, err) = withActionContainer() { c =>
         val (initCode, _) = c.init(initPayload(codeNotReturningJson))
         initCode should be(200)
         val (runCode, out) = c.run(JsObject())
         runCode should be(502)
         out should be(Some(JsObject("error" -> JsString("The action did not return a dictionary."))))
       }

       checkStreams(out, err, {
         case (o, e) =>
           if (checkResultInLogs) {
             (o + e) should include("not a json object")
           } else {
             o shouldBe empty
             e shouldBe empty
           }
       })
     }
   }

   /**
    * Runs tests for code samples which are expected to echo the input arguments
    * and print hello [stdout, stderr].
    */
   def testEcho(stdCodeSamples: Seq[(String, String)]) = {
     stdCodeSamples.foreach { s =>
       it should s"run a ${s._1} script" in {
         val argss = List(
           JsObject("string" -> JsString("hello")),
           JsObject("string" -> JsString("❄ ☃ ❄")),
           JsObject("numbers" -> JsArray(JsNumber(42), JsNumber(1))),
           // JsObject("boolean" -> JsBoolean(true)), // fails with swift3 returning boolean: 1
           JsObject("object" -> JsObject("a" -> JsString("A"))))

         val (out, err) = withActionContainer() { c =>
           val (initCode, _) = c.init(initPayload(s._2))
           initCode should be(200)

           for (args <- argss) {
             val (runCode, out) = c.run(runPayload(args))
             runCode should be(200)
             out should be(Some(args))
           }
         }

         checkStreams(out, err, {
           case (o, e) =>
             o should include("hello stdout")
             e should include("hello stderr")
         }, argss.length)
       }
     }
   }

   def testUnicode(stdUnicodeSamples: Seq[(String, String)]) = {
     stdUnicodeSamples.foreach { s =>
       it should s"run a ${s._1} action and handle unicode in source, input params, logs, and result" in {
         val (out, err) = withActionContainer() { c =>
           val (initCode, _) = c.init(initPayload(s._2))
           initCode should be(200)

           val (runCode, runRes) = c.run(runPayload(JsObject("delimiter" -> JsString("❄"))))
           runRes.get.fields.get("winter") shouldBe Some(JsString("❄ ☃ ❄"))
         }

         checkStreams(out, err, {
           case (o, _) =>
             o.toLowerCase should include("❄ ☃ ❄")
         })
       }
     }
   }

   /** Runs tests for code samples which are expected to return the expected standard environment {auth, edge}. */
   def testEnv(stdEnvSamples: Seq[(String, String)],
               enforceEmptyOutputStream: Boolean = true,
               enforceEmptyErrorStream: Boolean = true) = {
     stdEnvSamples.foreach { s =>
       it should s"run a ${s._1} script and confirm expected environment variables" in {
         val props = Seq(
           "api_host" -> "xyz",
           "api_key" -> "abc",
           "namespace" -> "zzz",
           "action_name" -> "xxx",
           "activation_id" -> "iii",
           "deadline" -> "123")
         val env = props.map { case (k, v) => s"__OW_${k.toUpperCase()}" -> v }

         val (out, err) = withActionContainer(env.take(1).toMap) { c =>
           val (initCode, _) = c.init(initPayload(s._2))
           initCode should be(200)

           val (runCode, out) = c.run(runPayload(JsObject(), Some(props.toMap.toJson.asJsObject)))
           runCode should be(200)
           out shouldBe defined
           props.map {
             case (k, v) =>
               withClue(k) {
                 out.get.fields(k) shouldBe JsString(v)
               }

           }
         }

         checkStreams(out, err, {
           case (o, e) =>
             if (enforceEmptyOutputStream) o shouldBe empty
             if (enforceEmptyErrorStream) e shouldBe empty
         })
       }
     }
   }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 actionContainers

	import java.io.File
	import java.util.Base64

	import org.apache.commons.io.FileUtils
	import org.junit.runner.RunWith
	import org.scalatest.junit.JUnitRunner

	import ActionContainer.withContainer
	import common.TestUtils
	import common.WskActorSystem
	import spray.json.DefaultJsonProtocol._
	import spray.json._

	@RunWith(classOf[JUnitRunner])
	class ActionProxyContainerTests extends BasicActionRunnerTests with WskActorSystem {

	override def withActionContainer(env: Map[String, String] = Map.empty)(code: ActionContainer => Unit) = {
	withContainer("dockerskeleton", env)(code)
	}

	val codeNotReturningJson = """
	\|#!/bin/sh
	\|echo not a json object
	""".stripMargin.trim

	/** Standard code samples, should print 'hello' to stdout and echo the input args. */
	val stdCodeSamples = {
	val bash = """
	\|#!/bin/bash
	\|echo 'hello stdout'
	\|echo 'hello stderr' 1>&2
	\|if [[ -z $1 \|\| $1 == '{}' ]]; then
	\| echo '{ "msg": "Hello from bash script!" }'
	\|else
	\| echo $1 # echo the arguments back as the result
	\|fi
	""".stripMargin.trim

	val python = """
	\|#!/usr/bin/env python
	\|from __future__ import print_function
	\|import sys
	\|print('hello stdout')
	\|print('hello stderr', file=sys.stderr)
	\|print(sys.argv[1])
	""".stripMargin.trim

	val perl = """
	\|#!/usr/bin/env perl
	\|print STDOUT "hello stdout\n";
	\|print STDERR "hello stderr\n";
	\|print $ARGV[0];
	""".stripMargin.trim

	// excluding perl as it not installed in alpine based image
	Seq(("bash", bash), ("python", python))
	}

	val stdUnicodeSamples = {
	// python 3 in base image
	val python = """
	\|#!/usr/bin/env python
	\|import json, sys
	\|j = json.loads(sys.argv[1])
	\|sep = j["delimiter"]
	\|s = sep + " ☃ " + sep
	\|print(s)
	\|print(json.dumps({"winter": s}))
	""".stripMargin.trim

	Seq(("python", python))
	}

	/** Standard code samples, should print 'hello' to stdout and echo the input args. */
	val stdEnvSamples = {
	val bash = """
	\|#!/bin/bash
	\|echo "{ \
	\|\"api_host\": \"$__OW_API_HOST\", \"api_key\": \"$__OW_API_KEY\", \
	\|\"namespace\": \"$__OW_NAMESPACE\", \"action_name\": \"$__OW_ACTION_NAME\", \
	\|\"activation_id\": \"$__OW_ACTIVATION_ID\", \"deadline\": \"$__OW_DEADLINE\" }"
	""".stripMargin.trim

	val python =
	"""
	\|#!/usr/bin/env python
	\|import os
	\|
	\|print('{ "api_host": "%s", "api_key": "%s", "namespace": "%s", "action_name" : "%s", "activation_id": "%s", "deadline": "%s" }' % (
	\| os.environ['__OW_API_HOST'], os.environ['__OW_API_KEY'],
	\| os.environ['__OW_NAMESPACE'], os.environ['__OW_ACTION_NAME'],
	\| os.environ['__OW_ACTIVATION_ID'], os.environ['__OW_DEADLINE']))
	""".stripMargin.trim

	val perl =
	"""
	\|#!/usr/bin/env perl
	\|$a = $ENV{'__OW_API_HOST'};
	\|$b = $ENV{'__OW_API_KEY'};
	\|$c = $ENV{'__OW_NAMESPACE'};
	\|$d = $ENV{'__OW_ACTION_NAME'};
	\|$e = $ENV{'__OW_ACTIVATION_ID'};
	\|$f = $ENV{'__OW_DEADLINE'};
	\|print "{ \"api_host\": \"$a\", \"api_key\": \"$b\", \"namespace\": \"$c\", \"action_name\": \"$d\", \"activation_id\": \"$e\", \"deadline\": \"$f\" }";
	""".stripMargin.trim

	// excluding perl as it not installed in alpine based image
	Seq(("bash", bash), ("python", python))
	}

	behavior of "openwhisk/dockerskeleton"

	it should "run sample without init" in {
	val (out, err) = withActionContainer() { c =>
	val (runCode, out) = c.run(JsObject())
	runCode should be(200)
	out should be(Some(JsObject("error" -> JsString("This is a stub action. Replace it with custom logic."))))
	}

	checkStreams(out, err, {
	case (o, _) => o should include("This is a stub action")
	})
	}

	it should "run sample with 'null' init" in {
	val (out, err) = withActionContainer() { c =>
	val (initCode, _) = c.init(initPayload(null))
	initCode should be(200)

	val (runCode, out) = c.run(JsObject())
	runCode should be(200)
	out should be(Some(JsObject("error" -> JsString("This is a stub action. Replace it with custom logic."))))
	}

	checkStreams(out, err, {
	case (o, _) => o should include("This is a stub action")
	})
	}

	it should "run sample with init that does nothing" in {
	val (out, err) = withActionContainer() { c =>
	val (initCode, _) = c.init(JsObject())
	initCode should be(200)
	val (runCode, out) = c.run(JsObject())
	runCode should be(200)
	out should be(Some(JsObject("error" -> JsString("This is a stub action. Replace it with custom logic."))))
	}

	checkStreams(out, err, {
	case (o, _) => o should include("This is a stub action")
	})
	}

	it should "respond with 404 for bad run argument" in {
	val (out, err) = withActionContainer() { c =>
	val (runCode, out) = c.run(runPayload(JsString("A")))
	runCode should be(404)
	}

	checkStreams(out, err, {
	case (o, e) =>
	o shouldBe empty
	e shouldBe empty
	})
	}

	it should "fail to run a bad script" in {
	val (out, err) = withActionContainer() { c =>
	val (initCode, _) = c.init(initPayload(""))
	initCode should be(200)
	val (runCode, out) = c.run(JsNull)
	runCode should be(502)
	out should be(Some(JsObject("error" -> JsString("The action did not return a dictionary."))))
	}

	checkStreams(out, err, {
	case (o, _) => o should include("error")
	})
	}

	it should "extract and run a compatible zip exec" in {
	val zip = FileUtils.readFileToByteArray(new File(TestUtils.getTestActionFilename("blackbox.zip")))
	val contents = Base64.getEncoder.encodeToString(zip)

	val (out, err) = withActionContainer() { c =>
	val (initCode, err) =
	c.init(JsObject("value" -> JsObject("code" -> JsString(contents), "binary" -> JsBoolean(true))))
	initCode should be(200)
	val (runCode, out) = c.run(JsObject())
	runCode should be(200)
	out.get should be(JsObject("msg" -> JsString("hello zip")))
	}

	checkStreams(out, err, {
	case (o, e) =>
	o shouldBe "This is an example zip used with the docker skeleton action."
	e shouldBe empty
	})
	}

	testNotReturningJson(codeNotReturningJson, checkResultInLogs = true)
	testEcho(stdCodeSamples)
	testUnicode(stdUnicodeSamples)
	testEnv(stdEnvSamples)
	}

	trait BasicActionRunnerTests extends ActionProxyContainerTestUtils {
	def withActionContainer(env: Map[String, String] = Map.empty)(code: ActionContainer => Unit): (String, String)

	/**
	* Runs tests for actions which do not return a dictionary and confirms expected error messages.
	* @param codeNotReturningJson code to execute, should not return a JSON object
	* @param checkResultInLogs should be true iff the result of the action is expected to appear in stdout or stderr
	*/
	def testNotReturningJson(codeNotReturningJson: String, checkResultInLogs: Boolean = true) = {
	it should "run and report an error for script not returning a json object" in {
	val (out, err) = withActionContainer() { c =>
	val (initCode, _) = c.init(initPayload(codeNotReturningJson))
	initCode should be(200)
	val (runCode, out) = c.run(JsObject())
	runCode should be(502)
	out should be(Some(JsObject("error" -> JsString("The action did not return a dictionary."))))
	}

	checkStreams(out, err, {
	case (o, e) =>
	if (checkResultInLogs) {
	(o + e) should include("not a json object")
	} else {
	o shouldBe empty
	e shouldBe empty
	}
	})
	}
	}

	/**
	* Runs tests for code samples which are expected to echo the input arguments
	* and print hello [stdout, stderr].
	*/
	def testEcho(stdCodeSamples: Seq[(String, String)]) = {
	stdCodeSamples.foreach { s =>
	it should s"run a ${s._1} script" in {
	val argss = List(
	JsObject("string" -> JsString("hello")),
	JsObject("string" -> JsString("❄ ☃ ❄")),
	JsObject("numbers" -> JsArray(JsNumber(42), JsNumber(1))),
	// JsObject("boolean" -> JsBoolean(true)), // fails with swift3 returning boolean: 1
	JsObject("object" -> JsObject("a" -> JsString("A"))))

	val (out, err) = withActionContainer() { c =>
	val (initCode, _) = c.init(initPayload(s._2))
	initCode should be(200)

	for (args <- argss) {
	val (runCode, out) = c.run(runPayload(args))
	runCode should be(200)
	out should be(Some(args))
	}
	}

	checkStreams(out, err, {
	case (o, e) =>
	o should include("hello stdout")
	e should include("hello stderr")
	}, argss.length)
	}
	}
	}

	def testUnicode(stdUnicodeSamples: Seq[(String, String)]) = {
	stdUnicodeSamples.foreach { s =>
	it should s"run a ${s._1} action and handle unicode in source, input params, logs, and result" in {
	val (out, err) = withActionContainer() { c =>
	val (initCode, _) = c.init(initPayload(s._2))
	initCode should be(200)

	val (runCode, runRes) = c.run(runPayload(JsObject("delimiter" -> JsString("❄"))))
	runRes.get.fields.get("winter") shouldBe Some(JsString("❄ ☃ ❄"))
	}

	checkStreams(out, err, {
	case (o, _) =>
	o.toLowerCase should include("❄ ☃ ❄")
	})
	}
	}
	}

	/** Runs tests for code samples which are expected to return the expected standard environment {auth, edge}. */
	def testEnv(stdEnvSamples: Seq[(String, String)],
	enforceEmptyOutputStream: Boolean = true,
	enforceEmptyErrorStream: Boolean = true) = {
	stdEnvSamples.foreach { s =>
	it should s"run a ${s._1} script and confirm expected environment variables" in {
	val props = Seq(
	"api_host" -> "xyz",
	"api_key" -> "abc",
	"namespace" -> "zzz",
	"action_name" -> "xxx",
	"activation_id" -> "iii",
	"deadline" -> "123")
	val env = props.map { case (k, v) => s"__OW_${k.toUpperCase()}" -> v }

	val (out, err) = withActionContainer(env.take(1).toMap) { c =>
	val (initCode, _) = c.init(initPayload(s._2))
	initCode should be(200)

	val (runCode, out) = c.run(runPayload(JsObject(), Some(props.toMap.toJson.asJsObject)))
	runCode should be(200)
	out shouldBe defined
	props.map {
	case (k, v) =>
	withClue(k) {
	out.get.fields(k) shouldBe JsString(v)
	}

	}
	}

	checkStreams(out, err, {
	case (o, e) =>
	if (enforceEmptyOutputStream) o shouldBe empty
	if (enforceEmptyErrorStream) e shouldBe empty
	})
	}
	}
	}
	}