This is an automated email from the ASF dual-hosted git repository.
houshengbo pushed a commit to branch master
in repository
https://gitbox.apache.org/repos/asf/incubator-openwhisk-wskdeploy.git
The following commit(s) were added to refs/heads/master by this push:
new 1b646cf Use data files for manifest tests and simplify (#668)
1b646cf is described below
commit 1b646cf0fbe8056202f8aef93eefe2b9dd0300af
Author: Matt Rutkowski <[email protected]>
AuthorDate: Tue Dec 12 15:29:02 2017 -0600
Use data files for manifest tests and simplify (#668)
* Use data files for tests and simplify.
* Use common function for basic manifest-action tests.
* Further simplify tests using shared function.
* Further simplify tests using shared function.
* Further simplify tests.
* Further simplify tests.
---
cmd/add.go | 29 +-
cmd/root.go | 7 +-
parsers/manifest_parser_test.go | 675 ++++++++++++-----------
parsers/yamlparser.go | 32 +-
tests/dat/manifest_hello_java_jar.yaml | 7 +
tests/dat/manifest_hello_nodejs.yaml | 6 +
tests/dat/manifest_hello_nodejs_with_params.yaml | 9 +
tests/dat/manifest_hello_python.yaml | 6 +
tests/dat/manifest_hello_swift.yaml | 6 +
tests/dat/manifest_invalid_package_missing.yaml | 6 +
wskderrors/wskdeployerror_test.go | 5 -
11 files changed, 435 insertions(+), 353 deletions(-)
diff --git a/cmd/add.go b/cmd/add.go
index dbf2574..d18a86d 100644
--- a/cmd/add.go
+++ b/cmd/add.go
@@ -44,25 +44,26 @@ var actionCmd = &cobra.Command{
return err
}
- reader := bufio.NewReader(os.Stdin)
- action := parsers.Action{}
+ reader := bufio.NewReader(os.Stdin)
+ action := parsers.Action{}
- for {
- action.Name = utils.Ask(reader, "Name", "")
+ for {
+ action.Name = utils.Ask(reader, "Name", "")
- // Check action name is unique
- if _, ok := maniyaml.Package.Actions[action.Name]; !ok {
- break
- }
- fmt.Print(action.Name + " is already used. Pick another
action name\n")
+ // Check action name is unique
+ if _, ok := maniyaml.Package.Actions[action.Name]; !ok {
+ break
}
+ fmt.Print(action.Name + " is already used. Pick another action
name\n")
+ }
+
+ action.Runtime = utils.Ask(reader, "Runtime", "nodejs:6")
+ maniyaml.Package.Actions[action.Name] = action
- action.Runtime = utils.Ask(reader, "Runtime", "nodejs:6")
- maniyaml.Package.Actions[action.Name] = action
+ // Create directory structure before update manifest, as a way
+ // to check the action name is a valid path name
+ err = os.MkdirAll("actions/"+action.Name, 0777)
- // Create directory structure before update manifest, as a way
- // to check the action name is a valid path name
- err = os.MkdirAll("actions/"+action.Name, 0777)
if err != nil {
return err
}
diff --git a/cmd/root.go b/cmd/root.go
index d07005f..fd0642d 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -155,8 +155,8 @@ func setSupportedRuntimes(apiHost string) {
func Deploy() error {
whisk.SetVerbose(utils.Flags.Verbose)
- // Verbose mode is the only mode for wskdeploy to turn on all the debug
messages, so the currenty Verbose mode
- // also set debug mode to true.
+ // Verbose mode is the only mode for wskdeploy to turn on all the debug
messages,
+ // so set Verbose mode (and also debug mode) to true.
whisk.SetDebug(utils.Flags.Verbose)
project_Path := strings.TrimSpace(utils.Flags.ProjectPath)
@@ -181,6 +181,8 @@ func Deploy() error {
errString := wski18n.T("Missing {{.yaml}}/{{.yml}}
file. Manifest file not found at path {{.projectPath}}.\n",
map[string]interface{}{"yaml":
utils.ManifestFileNameYaml, "yml": utils.ManifestFileNameYml,
"projectPath": projectPath})
+
+ // TODO() print help on error
return
wskderrors.NewErrorManifestFileNotFound(projectPath, errString)
}
whisk.Debug(whisk.DbgInfo, stdout)
@@ -230,6 +232,7 @@ func Deploy() error {
}
err = deployer.Deploy()
+
if err != nil {
return err
} else {
diff --git a/parsers/manifest_parser_test.go b/parsers/manifest_parser_test.go
index f31b55c..54d0a0d 100644
--- a/parsers/manifest_parser_test.go
+++ b/parsers/manifest_parser_test.go
@@ -33,172 +33,190 @@ import (
"github.com/apache/incubator-openwhisk-wskdeploy/wskderrors"
)
-// Test 1: validate manifest_parser:Unmarshal() method with a sample manifest
in NodeJS
-// validate that manifest_parser is able to read and parse the manifest data
-func TestUnmarshalForHelloNodeJS(t *testing.T) {
- data := `
-package:
- name: helloworld
- actions:
- helloNodejs:
- function: actions/hello.js
- runtime: nodejs:6`
- // set the zero value of struct YAML
+const (
+ // local test assert messages
+ TEST_MSG_PACKAGE_NAME_MISSING = "Package named [%s] missing."
+ TEST_MSG_PACKAGE_NAME_MISMATCH = "Package name mismatched."
+ TEST_MSG_ACTION_NUMBER_MISMATCH = "Number of Actions mismatched."
+ TEST_MSG_ACTION_NAME_MISSING = "Action named [%s] does not exist."
+ TEST_MSG_ACTION_FUNCTION_PATH_MISMATCH = "Action function path mismatched."
+ TEST_MSG_ACTION_FUNCTION_RUNTIME_MISMATCH = "Action function runtime
mismatched."
+ TEST_MSG_ACTION_FUNCTION_MAIN_MISMATCH = "Action function main name
mismatch."
+ TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH = "Action parameter [%s] had a
type mismatch."
+ TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH = "Action parameter [%s] had a
value mismatch."
+ TEST_MSG_PARAMETER_NUMBER_MISMATCH = "Number of Paramaters mismatched."
+ TEST_MSG_MANIFEST_UNMARSHALL_ERROR_EXPECTED = "Manifest [%s]: Expected
Unmarshal error."
+
+ // local error messages
+ TEST_ERROR_MANIFEST_PARSE_FAILURE = "Manifest [%s]: Failed to parse."
+ TEST_ERROR_MANIFEST_READ_FAILURE = "Manifest [%s]: Failed to ReadFile()."
+ TEST_ERROR_MANIFEST_DATA_UNMARSHALL = "Manifest [%s]: Failed to Unmarshall
manifest."
+)
+
+
+func testReadAndUnmarshalManifest(t *testing.T, pathManifest string)(YAML,
error){
+ // Init YAML struct and attempt to Unmarshal YAML byte[] data
m := YAML{}
- // Unmarshal reads/parses manifest data and sets the values of YAML
- // And returns an error if parsing a manifest data fails
- err := NewYAMLParser().Unmarshal([]byte(data), &m)
- if err == nil {
- // YAML.Filepath does not get set by Parsers.Unmarshal
- // as it takes manifest YAML data as a function parameter
- // instead of file name of a manifest file, therefore there is
- // no way for Unmarshal function to set YAML.Filepath field
- // (TODO) Ideally we should change this functionality so that
- // (TODO) filepath is set to the actual path of the manifest file
- expectedResult := ""
- actualResult := m.Filepath
- assert.Equal(t, expectedResult, actualResult, "Expected filepath to be
an empty" +
- " string instead its set to " + actualResult + " which is invalid
value")
- // package name should be "helloworld"
- expectedResult = "helloworld"
- actualResult = m.Package.Packagename
- assert.Equal(t, expectedResult, actualResult, "Expected package name "
+ expectedResult + " but got " + actualResult)
- // manifest should contain only one action
- expectedResult = string(1)
- actualResult = string(len(m.Package.Actions))
- assert.Equal(t, expectedResult, actualResult, "Expected 1 but got " +
actualResult)
- // get the action payload from the map of actions which is stored in
- // YAML.Package.Actions with the type of map[string]Action
- actionName := "helloNodejs"
- if action, ok := m.Package.Actions[actionName]; ok {
- // location/function of an action should be "actions/hello.js"
- expectedResult = "actions/hello.js"
- actualResult = action.Function
- assert.Equal(t, expectedResult, actualResult, "Expected action
function " + expectedResult + " but got " + actualResult)
- // runtime of an action should be "nodejs:6"
- expectedResult = "nodejs:6"
- actualResult = action.Runtime
- assert.Equal(t, expectedResult, actualResult, "Expected action
runtime " + expectedResult + " but got " + actualResult)
+
+ // read raw bytes of manifest.yaml file
+ data, err := ioutil.ReadFile(pathManifest)
+
+ if err != nil{
+ t.Error(fmt.Sprintf(TEST_ERROR_MANIFEST_READ_FAILURE, pathManifest))
+ return m, err
+ }
+
+ err = NewYAMLParser().Unmarshal([]byte(data), &m)
+ return m, err
+}
+
+
+/*
+ testUnmarshalManifestAndActionBasic
+
+ This function validates basic Manifest Package and Action keys including
+ - Package name mismatch (single "package" only)
+ - Number of Actions mismatch
+ - Action Function path mismatch
+ - Action runtime (name) mismatch
+
+ and optionally,
+ = Action function "main" name mismatch
+
+ Returns:
+ - N/A
+ */
+func testUnmarshalManifestAndActionBasic(t *testing.T,
+ pathManifest string,
+ namePackage string,
+ numActions int,
+ nameAction string,
+ pathFunction string,
+ nameRuntime string,
+ nameMain string) (YAML, error){
+
+ // Test that we are able to read the manifest file and unmarshall into
YAML struct
+ m, err := testReadAndUnmarshalManifest(t, pathManifest)
+
+ // nothing to test if Unmarshal returns an err
+ if err != nil {
+ assert.Fail(t, fmt.Sprintf(TEST_ERROR_MANIFEST_DATA_UNMARSHALL,
pathManifest))
+ } else {
+ // test package name
+ actualResult := m.Package.Packagename
+ assert.Equal(t, namePackage, actualResult,
TEST_MSG_PACKAGE_NAME_MISMATCH)
+
+ // test # of actions in manifest
+ if numActions >0 {
+ actualResult = string(len(m.Package.Actions))
+ assert.Equal(t, string(numActions), actualResult,
TEST_MSG_ACTION_NUMBER_MISMATCH)
+ }
+
+ // get an action from map of actions where key is action name and
value is Action struct
+ if action, ok := m.Package.Actions[nameAction]; ok {
+
+ // test action's function path
+ assert.Equal(t, pathFunction, action.Function,
TEST_MSG_ACTION_FUNCTION_PATH_MISMATCH)
+
+ // test action's runtime
+ assert.Equal(t, nameRuntime, action.Runtime,
TEST_MSG_ACTION_FUNCTION_RUNTIME_MISMATCH)
+
+ // test action's "Main" function
+ if nameMain != "" {
+ assert.Equal(t, nameMain, action.Main,
TEST_MSG_ACTION_FUNCTION_MAIN_MISMATCH)
+ }
+
} else {
- t.Error("Action named " + actionName + " does not exist.")
+ t.Error(fmt.Sprintf(TEST_MSG_ACTION_NAME_MISSING, nameAction))
}
}
+ return m, nil
+}
+
+// Test 1: validate manifest_parser:Unmarshal() method with a sample manifest
in NodeJS
+// validate that manifest_parser is able to read and parse the manifest data
+func TestUnmarshalForHelloNodeJS(t *testing.T) {
+ testUnmarshalManifestAndActionBasic(t,
+ "../tests/dat/manifest_hello_nodejs.yaml", // Manifest path
+ "helloworld", // Package name
+ 1, // # of Actions
+ "helloNodejs", // Action name
+ "actions/hello.js", // Function path
+ "nodejs:6", // "Runtime
+ "") // "Main" function name
}
// Test 2: validate manifest_parser:Unmarshal() method with a sample manifest
in Java
// validate that manifest_parser is able to read and parse the manifest data
func TestUnmarshalForHelloJava(t *testing.T) {
- data := `
-package:
- name: helloworld
- actions:
- helloJava:
- function: actions/hello.jar
- runtime: java
- main: Hello`
- m := YAML{}
- err := NewYAMLParser().Unmarshal([]byte(data), &m)
- // nothing to test if Unmarshal returns an err
- if err == nil {
- // get an action from map of actions where key is action name and
- // value is Action struct
- actionName := "helloJava"
- if action, ok := m.Package.Actions[actionName]; ok {
- // runtime of an action should be java
- expectedResult := "java"
- actualResult := action.Runtime
- assert.Equal(t, expectedResult, actualResult, "Expected action
runtime " + expectedResult + " but got " + actualResult)
- // Main field should be set to "Hello"
- expectedResult = action.Main
- actualResult = "Hello"
- assert.Equal(t, expectedResult, actualResult, "Expected action
main function " + expectedResult + " but got " + actualResult)
- } else {
- t.Error("Expected action named " + actionName + " but does not
exist.")
- }
- }
+ testUnmarshalManifestAndActionBasic(t,
+ "../tests/dat/manifest_hello_java_jar.yaml", // Manifest path
+ "helloworld", // Package name
+ 1, // # of Actions
+ "helloJava", // Action name
+ "actions/hello.jar", // Function path
+ "java", // "Runtime
+ "Hello") // "Main" function name
}
// Test 3: validate manifest_parser:Unmarshal() method with a sample manifest
in Python
// validate that manifest_parser is able to read and parse the manifest data
func TestUnmarshalForHelloPython(t *testing.T) {
- data := `
-package:
- name: helloworld
- actions:
- helloPython:
- function: actions/hello.py
- runtime: python`
- m := YAML{}
- err := NewYAMLParser().Unmarshal([]byte(data), &m)
- // nothing to test if Unmarshal returns an err
- if err == nil {
- // get an action from map of actions which is defined as
map[string]Action{}
- actionName := "helloPython"
- if action, ok := m.Package.Actions[actionName]; ok {
- // runtime of an action should be python
- expectedResult := "python"
- actualResult := action.Runtime
- assert.Equal(t, expectedResult, actualResult, "Expected action
runtime " + expectedResult + " but got " + actualResult)
- } else {
- t.Error("Expected action named " + actionName + " but does not
exist.")
- }
- }
+ testUnmarshalManifestAndActionBasic(t,
+ "../tests/dat/manifest_hello_python.yaml", // Manifest path
+ "helloworld", // Package name
+ 1, // # of Actions
+ "helloPython", // Action name
+ "actions/hello.py", // Function path
+ "python", // "Runtime
+ "") // "Main" function name
}
// Test 4: validate manifest_parser:Unmarshal() method with a sample manifest
in Swift
// validate that manifest_parser is able to read and parse the manifest data
func TestUnmarshalForHelloSwift(t *testing.T) {
- data := `
-package:
- name: helloworld
- actions:
- helloSwift:
- function: actions/hello.swift
- runtime: swift`
- m := YAML{}
- err := NewYAMLParser().Unmarshal([]byte(data), &m)
- // nothing to test if Unmarshal returns an err
- if err == nil {
- // get an action from map of actions which is defined as
map[string]Action{}
- actionName := "helloSwift"
- if action, ok := m.Package.Actions[actionName]; ok {
- // runtime of an action should be swift
- expectedResult := "swift"
- actualResult := action.Runtime
- assert.Equal(t, expectedResult, actualResult, "Expected action
runtime " + expectedResult + " but got " + actualResult)
- } else {
- t.Error("Expected action named " + actionName + " but does not
exist.")
- }
- }
+ testUnmarshalManifestAndActionBasic(t,
+ "../tests/dat/manifest_hello_swift.yaml", // Manifest path
+ "helloworld", // Package name
+ 1, // # of Actions
+ "helloSwift", // Action name
+ "actions/hello.swift", // Function path
+ "swift", // "Runtime
+ "") // "Main" function name
}
// Test 5: validate manifest_parser:Unmarshal() method for an action with
parameters
// validate that manifest_parser is able to read and parse the manifest data,
specially
// validate two input parameters and their values
func TestUnmarshalForHelloWithParams(t *testing.T) {
- var data = `
-package:
- name: helloworld
- actions:
- helloWithParams:
- function: actions/hello-with-params.js
- runtime: nodejs:6
- inputs:
- name: Amy
- place: Paris`
- m := YAML{}
- err := NewYAMLParser().Unmarshal([]byte(data), &m)
- if err == nil {
- actionName := "helloWithParams"
- if action, ok := m.Package.Actions[actionName]; ok {
- expectedResult := "Amy"
- actualResult := action.Inputs["name"].Value.(string)
- assert.Equal(t, expectedResult, actualResult,
- "Expected input parameter " + expectedResult + " but got " +
actualResult + "for name")
- expectedResult = "Paris"
- actualResult = action.Inputs["place"].Value.(string)
- assert.Equal(t, expectedResult, actualResult,
- "Expected input parameter " + expectedResult + " but got " +
actualResult + "for place")
+
+ TEST_ACTION_NAME := "helloWithParams"
+ TEST_PARAM_NAME_1 := "name"
+ TEST_PARAM_VALUE_1 := "Amy"
+ TEST_PARAM_NAME_2 := "place"
+ TEST_PARAM_VALUE_2 := "Paris"
+
+ m, err := testUnmarshalManifestAndActionBasic(t,
+ "../tests/dat/manifest_hello_nodejs_with_params.yaml", // Manifest
path
+ "helloworld", // Package name
+ 1, // # of Actions
+ TEST_ACTION_NAME, // Action name
+ "actions/hello-with-params.js", // Function path
+ "nodejs:6", // "Runtime
+ "") // "Main" function name
+
+ if err != nil {
+ if action, ok := m.Package.Actions[TEST_ACTION_NAME]; ok {
+
+ // test action parameters
+ actualResult := action.Inputs[TEST_PARAM_NAME_1].Value.(string)
+ assert.Equal(t, TEST_PARAM_VALUE_1, actualResult,
+ fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH,
TEST_PARAM_NAME_1))
+
+ actualResult = action.Inputs[TEST_PARAM_NAME_2].Value.(string)
+ assert.Equal(t, TEST_PARAM_VALUE_2, actualResult,
+ fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH,
TEST_PARAM_NAME_2))
+
}
}
}
@@ -206,20 +224,10 @@ package:
// Test 6: validate manifest_parser:Unmarshal() method for an invalid manifest
// manifest_parser should report an error when a package section is missing
func TestUnmarshalForMissingPackage(t *testing.T) {
- data := `
- actions:
- helloNodejs:
- function: actions/hello.js
- runtime: nodejs:6
- helloJava:
- function: actions/hello.java`
- // set the zero value of struct YAML
- m := YAML{}
- // Unmarshal reads/parses manifest data and sets the values of YAML
- // And returns an error if parsing a manifest data fails
- err := NewYAMLParser().Unmarshal([]byte(data), &m)
- assert.NotNil(t, err, "Expected some error from Unmarshal but got no
error")
+ TEST_MANIFEST := "../tests/dat/manifest_invalid_package_missing.yaml"
+ _, err := testReadAndUnmarshalManifest(t, TEST_MANIFEST)
+ assert.NotNil(t, err,
fmt.Sprintf(TEST_MSG_MANIFEST_UNMARSHALL_ERROR_EXPECTED, TEST_MANIFEST))
}
/*
@@ -231,39 +239,41 @@ func TestParseManifestForMultiLineParams(t *testing.T) {
// manifest file is located under ../tests folder
manifestFile := "../tests/dat/manifest_validate_multiline_params.yaml"
// read and parse manifest.yaml file
- m, _ := NewYAMLParser().ParseManifest(manifestFile)
+ m, err := NewYAMLParser().ParseManifest(manifestFile)
+
+ if err != nil {
+ assert.Fail(t, fmt.Sprintf(TEST_ERROR_MANIFEST_PARSE_FAILURE,
manifestFile))
+ }
// validate package name should be "validate"
packageName := "validate"
- assert.NotNil(t, m.Packages[packageName],
- "Expected package named validate but got none")
// validate this package contains one action
expectedActionsCount := 1
actualActionsCount := len(m.Packages[packageName].Actions)
- assert.Equal(t, expectedActionsCount, actualActionsCount,
- "Expected " + string(expectedActionsCount) + " but got " +
string(actualActionsCount))
+ assert.Equal(t, expectedActionsCount, actualActionsCount,
TEST_MSG_ACTION_NUMBER_MISMATCH)
// here Package.Actions holds a map of map[string]Action
// where string is the action name so in case you create two actions with
// same name, will go unnoticed
// also, the Action struct does not have name field set it to action name
actionName := "validate_multiline_params"
+
if action, ok := m.Packages[packageName].Actions[actionName]; ok {
- // validate location/function of an action to be
"actions/dump_params.js"
+ // test action function's path
expectedResult := "actions/dump_params.js"
actualResult := action.Function
- assert.Equal(t, expectedResult, actualResult, "Expected action
function " + expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_ACTION_FUNCTION_PATH_MISMATCH)
- // validate runtime of an action to be "nodejs:6"
+ // test action's runtime
expectedResult = "nodejs:6"
actualResult = action.Runtime
- assert.Equal(t, expectedResult, actualResult, "Expected action runtime
" + expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_ACTION_FUNCTION_RUNTIME_MISMATCH)
- // validate the number of inputs to this action
+ // test # input params
expectedResult = strconv.FormatInt(10, 10)
actualResult = strconv.FormatInt(int64(len(action.Inputs)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_PARAMETER_NUMBER_MISMATCH)
// validate inputs to this action
for input, param := range action.Inputs {
@@ -271,55 +281,55 @@ func TestParseManifestForMultiLineParams(t *testing.T) {
case "param_string_value_only":
expectedResult = "foo"
actualResult = param.Value.(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_int_value_only":
expectedResult = strconv.FormatInt(123, 10)
actualResult = strconv.FormatInt(int64(param.Value.(int)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_float_value_only":
expectedResult = strconv.FormatFloat(3.14, 'f', -1, 64)
actualResult = strconv.FormatFloat(param.Value.(float64), 'f',
-1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_string_type_and_value_only":
expectedResult = "foo"
actualResult = param.Value.(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
expectedResult = "string"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_string_type_only":
expectedResult = "string"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_integer_type_only":
expectedResult = "integer"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_float_type_only":
expectedResult = "float"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_string_with_default":
expectedResult = "string"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
expectedResult = "bar"
actualResult = param.Default.(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_integer_with_default":
expectedResult = "integer"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
expectedResult = strconv.FormatInt(-1, 10)
actualResult = strconv.FormatInt(int64(param.Default.(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_float_with_default":
expectedResult = "float"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH, param))
expectedResult = strconv.FormatFloat(2.9, 'f', -1, 64)
actualResult = strconv.FormatFloat(param.Default.(float64),
'f', -1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
}
}
@@ -329,10 +339,10 @@ func TestParseManifestForMultiLineParams(t *testing.T) {
case "payload":
expectedType := "string"
actualType := param.Type
- assert.Equal(t, expectedType, actualType, "Expected Type: " +
expectedType + ", but got: " + actualType)
+ assert.Equal(t, expectedType, actualType,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH, param))
expectedDesc := "parameter dump"
actualDesc := param.Description
- assert.Equal(t, expectedDesc, actualDesc, "Expected " +
expectedDesc + " but got " + actualDesc)
+ assert.Equal(t, expectedDesc, actualDesc,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
}
}
@@ -344,36 +354,38 @@ func TestParseManifestForMultiLineParams(t *testing.T) {
func TestParseManifestForSingleLineParams(t *testing.T) {
// manifest file is located under ../tests folder
manifestFile := "../tests/dat/manifest_validate_singleline_params.yaml"
+
// read and parse manifest.yaml file
- m, _ := NewYAMLParser().ParseManifest(manifestFile)
+ m, err := NewYAMLParser().ParseManifest(manifestFile)
+
+ if err != nil {
+ assert.Fail(t, fmt.Sprintf(TEST_ERROR_MANIFEST_PARSE_FAILURE,
manifestFile))
+ }
// validate package name should be "validate"
packageName := "validate"
- assert.NotNil(t, m.Packages[packageName],
- "Expected package named "+ packageName + " but got none")
// validate this package contains one action
expectedActionsCount := 1
actualActionsCount := len(m.Packages[packageName].Actions)
- assert.Equal(t, expectedActionsCount, actualActionsCount,
- "Expected " + string(expectedActionsCount) + " but got " +
string(actualActionsCount))
+ assert.Equal(t, expectedActionsCount, actualActionsCount,
TEST_MSG_ACTION_NUMBER_MISMATCH)
actionName := "validate_singleline_params"
if action, ok := m.Packages[packageName].Actions[actionName]; ok {
- // validate location/function of an action to be
"actions/dump_params.js"
+ // test Action function's path
expectedResult := "actions/dump_params.js"
actualResult := action.Function
- assert.Equal(t, expectedResult, actualResult, "Expected action
function " + expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_ACTION_FUNCTION_PATH_MISMATCH)
- // validate runtime of an action to be "nodejs:6"
+ // test Action runtime
expectedResult = "nodejs:6"
actualResult = action.Runtime
- assert.Equal(t, expectedResult, actualResult, "Expected action runtime
" + expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_ACTION_FUNCTION_RUNTIME_MISMATCH)
- // validate the number of inputs to this action
+ // test # of inputs
expectedResult = strconv.FormatInt(22, 10)
actualResult = strconv.FormatInt(int64(len(action.Inputs)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_PARAMETER_NUMBER_MISMATCH)
// validate Inputs to this action
for input, param := range action.Inputs {
@@ -381,55 +393,55 @@ func TestParseManifestForSingleLineParams(t *testing.T) {
case "param_simple_string":
expectedResult = "foo"
actualResult = param.Value.(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_integer_1":
expectedResult = strconv.FormatInt(1, 10)
actualResult = strconv.FormatInt(int64(param.Value.(int)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_integer_2":
expectedResult = strconv.FormatInt(0, 10)
actualResult = strconv.FormatInt(int64(param.Value.(int)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_integer_3":
expectedResult = strconv.FormatInt(-1, 10)
actualResult = strconv.FormatInt(int64(param.Value.(int)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_integer_4":
expectedResult = strconv.FormatInt(99999, 10)
actualResult = strconv.FormatInt(int64(param.Value.(int)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_integer_5":
expectedResult = strconv.FormatInt(-99999, 10)
actualResult = strconv.FormatInt(int64(param.Value.(int)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_float_1":
expectedResult = strconv.FormatFloat(1.1, 'f', -1, 64)
actualResult = strconv.FormatFloat(param.Value.(float64), 'f',
-1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_float_2":
expectedResult = strconv.FormatFloat(0.0, 'f', -1, 64)
actualResult = strconv.FormatFloat(param.Value.(float64), 'f',
-1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_float_3":
expectedResult = strconv.FormatFloat(-1.1, 'f', -1, 64)
actualResult = strconv.FormatFloat(param.Value.(float64), 'f',
-1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_env_var_1":
expectedResult = "$GOPATH"
actualResult = param.Value.(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_invalid_env_var":
expectedResult = "$DollarSignNotInEnv"
actualResult = param.Value.(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
case "param_simple_implied_empty":
assert.Nil(t, param.Value, "Expected nil")
case "param_simple_explicit_empty_1":
actualResult = param.Value.(string)
- assert.Empty(t, actualResult, "Expected empty string but got "
+ actualResult)
+ assert.Empty(t, actualResult)
case "param_simple_explicit_empty_2":
actualResult = param.Value.(string)
- assert.Empty(t, actualResult, "Expected empty string but got "
+ actualResult)
+ assert.Empty(t, actualResult)
}
}
@@ -439,11 +451,11 @@ func TestParseManifestForSingleLineParams(t *testing.T) {
case "payload":
expectedResult = "string"
actualResult = param.Type
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH, param))
expectedResult = "parameter dump"
actualResult = param.Description
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, param))
}
}
}
@@ -489,7 +501,7 @@ func TestComposeActionsForImplicitRuntimes(t *testing.T) {
expectedResult = "swift:3.1.1"
}
actualResult := actions[i].Action.Exec.Kind
- assert.Equal(t, expectedResult, actualResult, "Expected "
+ expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_ACTION_FUNCTION_RUNTIME_MISMATCH)
}
}
@@ -521,9 +533,9 @@ func TestComposeActionsForInvalidRuntime(t *testing.T) {
// (TODO) uncomment the following test case after issue #307 is
fixed
// (TODO) its failing right now as we are lacking check on invalid
runtime
// TODO()
https://github.com/apache/incubator-openwhisk-wskdeploy/issues/608
- // assert.NotNil(t, err, "Invalid runtime, ComposeActions should
report an error")
+ //assert.NotNil(t, err, "Invalid runtime, ComposeActions should
report an error")
// (TODO) remove this print statement after uncommenting above
test case
- fmt.Println(err)
+ fmt.Println(fmt.Sprintf("!!! TODO(): Fix this testcase:
error=[%v]", err))
}
tmpfile.Close()
}
@@ -534,19 +546,21 @@ func TestComposeActionsForInvalidRuntime(t *testing.T) {
func TestComposeActionsForSingleLineParams(t *testing.T) {
// manifest file is located under ../tests folder
manifestFile := "../tests/dat/manifest_validate_singleline_params.yaml"
+
// read and parse manifest.yaml file
p := NewYAMLParser()
m, err := p.ParseManifest(manifestFile)
if err != nil {
- assert.Fail(t, "Failed to parse manifest: " + manifestFile )
+ assert.Fail(t, fmt.Sprintf(TEST_ERROR_MANIFEST_PARSE_FAILURE,
manifestFile))
}
+ // Call the method we are testing
actions, err := p.ComposeActionsFromAllPackages(m, manifestFile,
whisk.KeyValue{})
if err == nil {
- // assert that the actions variable has only one action
- assert.Equal(t, 1, len(actions), "We have defined only one action but
we got " + string(len(actions)))
+ // test # actions
+ assert.Equal(t, 1, len(actions), TEST_MSG_ACTION_NUMBER_MISMATCH)
action := actions[0]
@@ -555,135 +569,158 @@ func TestComposeActionsForSingleLineParams(t
*testing.T) {
*/
// param_simple_string should value "foo"
+ paramName := "param_simple_string"
expectedResult := "foo"
- actualResult :=
action.Action.Parameters.GetValue("param_simple_string").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult := action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
/*
* Simple 'integer' value tests
*/
// param_simple_integer_1 should have value 1
+ paramName = "param_simple_integer_1"
expectedResult = strconv.FormatInt(1, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_simple_integer_1").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_integer_2 should have value 0
+ paramName = "param_simple_integer_2"
expectedResult = strconv.FormatInt(0, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_simple_integer_2").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_integer_3 should have value -1
+ paramName = "param_simple_integer_3"
expectedResult = strconv.FormatInt(-1, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_simple_integer_3").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_integer_4 should have value 99999
+ paramName = "param_simple_integer_4"
expectedResult = strconv.FormatInt(99999, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_simple_integer_4").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_integer_5 should have value -99999
+ paramName = "param_simple_integer_5"
expectedResult = strconv.FormatInt(-99999, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_simple_integer_5").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
/*
* Simple 'float' value tests
*/
// param_simple_float_1 should have value 1.1
+ paramName = "param_simple_float_1"
expectedResult = strconv.FormatFloat(1.1, 'f', -1, 64)
- actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue("param_simple_float_1").(float64),
'f', -1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue(paramName).(float64),
'f', -1, 64)
+ assert.Equal(t, expectedResult,
actualResult,fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_float_2 should have value 0.0
+ paramName = "param_simple_float_2"
expectedResult = strconv.FormatFloat(0.0, 'f', -1, 64)
- actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue("param_simple_float_2").(float64),
'f', -1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue(paramName).(float64),
'f', -1, 64)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_float_3 should have value -1.1
+ paramName = "param_simple_float_3"
expectedResult = strconv.FormatFloat(-1.1, 'f', -1, 64)
- actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue("param_simple_float_3").(float64),
'f', -1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue(paramName).(float64),
'f', -1, 64)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
/*
* Environment Variable / dollar ($) notation tests
*/
// param_simple_env_var_1 should have value of env. variable $GOPATH
+ paramName = "param_simple_env_var_1"
expectedResult = os.Getenv("GOPATH")
- actualResult =
action.Action.Parameters.GetValue("param_simple_env_var_1").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_env_var_2 should have value of env. variable $GOPATH
+ paramName = "param_simple_env_var_2"
expectedResult = os.Getenv("GOPATH")
- actualResult =
action.Action.Parameters.GetValue("param_simple_env_var_2").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_env_var_3 should have value of env. variable "${}"
+ paramName = "param_simple_env_var_3"
expectedResult = "${}"
- actualResult =
action.Action.Parameters.GetValue("param_simple_env_var_3").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_invalid_env_var should have value of ""
+ paramName = "param_simple_invalid_env_var"
expectedResult = ""
- actualResult =
action.Action.Parameters.GetValue("param_simple_invalid_env_var").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
/*
* Environment Variable concatenation tests
*/
// param_simple_env_var_concat_1 should have value of env. variable
"$GOPTH/test" empty string
+ paramName = "param_simple_env_var_concat_1"
expectedResult = os.Getenv("GOPATH") + "/test"
- actualResult =
action.Action.Parameters.GetValue("param_simple_env_var_concat_1").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_env_var_concat_2 should have value of env. variable ""
empty string
// as the "/test" is treated as part of the environment var. and not
concatenated.
+ paramName = "param_simple_env_var_concat_2"
expectedResult = ""
- actualResult =
action.Action.Parameters.GetValue("param_simple_env_var_concat_2").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_env_var_concat_3 should have value of env. variable ""
empty string
+ paramName = "param_simple_env_var_concat_3"
expectedResult = "ddd.ccc." + os.Getenv("GOPATH")
- actualResult =
action.Action.Parameters.GetValue("param_simple_env_var_concat_3").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
/*
* Empty string tests
*/
// param_simple_implied_empty should be ""
- actualResult =
action.Action.Parameters.GetValue("param_simple_implied_empty").(string)
- assert.Empty(t, "", "Expected empty string but got " + actualResult)
+ paramName = "param_simple_implied_empty"
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Empty(t, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_explicit_empty_1 should be ""
- actualResult =
action.Action.Parameters.GetValue("param_simple_explicit_empty_1").(string)
- assert.Empty(t, "", "Expected empty string but got " + actualResult)
+ paramName = "param_simple_explicit_empty_1"
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Empty(t, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_explicit_empty_2 should be ""
- actualResult =
action.Action.Parameters.GetValue("param_simple_explicit_empty_2").(string)
- assert.Empty(t, "", "Expected empty string but got " + actualResult)
+ paramName = "param_simple_explicit_empty_2"
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Empty(t, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
/*
* Test values that contain "Type names" (e.g., "string", "integer",
"float, etc.)
*/
// param_simple_type_string should be "" when value set to "string"
- actualResult =
action.Action.Parameters.GetValue("param_simple_type_string").(string)
- assert.Empty(t, "", "Expected empty string but got " + actualResult)
+ paramName = "param_simple_type_string"
+ expectedResult = ""
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_type_integer should be 0.0 when value set to "integer"
+ paramName = "param_simple_type_integer"
expectedResult = strconv.FormatInt(0, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_simple_type_integer").(int)),
10)
- assert.Empty(t, 0, "Expected empty string but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_simple_type_float should be 0 when value set to "float"
+ paramName = "param_simple_type_float"
expectedResult = strconv.FormatFloat(0.0, 'f', -1, 64)
- actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue("param_simple_type_float").(float64),
'f', -1, 64)
- assert.Empty(t, 0.0, "Expected empty string but got " + actualResult)
+ actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue(paramName).(float64),
'f', -1, 64)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
}
}
@@ -693,72 +730,82 @@ func TestComposeActionsForSingleLineParams(t *testing.T) {
func TestComposeActionsForMultiLineParams(t *testing.T) {
// manifest file is located under ../tests folder
manifestFile := "../tests/dat/manifest_validate_multiline_params.yaml"
+
// read and parse manifest.yaml file
p := NewYAMLParser()
m, err := p.ParseManifest(manifestFile)
if err != nil {
- assert.Fail(t, "Failed to parse manifest: " + manifestFile )
+ assert.Fail(t, fmt.Sprintf(TEST_ERROR_MANIFEST_PARSE_FAILURE,
manifestFile))
}
+ // call the method we are testing
actions, err := p.ComposeActionsFromAllPackages(m, manifestFile,
whisk.KeyValue{})
if err == nil {
- // assert that the actions variable has only one action
- assert.Equal(t, 1, len(actions), "We have defined only one action but
we got " + string(len(actions)))
+ // test # actions
+ assert.Equal(t, 1, len(actions), TEST_MSG_ACTION_NUMBER_MISMATCH)
action := actions[0]
- fmt.Println(action.Action.Parameters)
-
// param_string_value_only should be "foo"
+ paramName := "param_string_value_only"
expectedResult := "foo"
- actualResult :=
action.Action.Parameters.GetValue("param_string_value_only").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult := action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_int_value_only should be 123
+ paramName = "param_int_value_only"
expectedResult = strconv.FormatInt(123, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_int_value_only").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_float_value_only should be 3.14
+ paramName = "param_float_value_only"
expectedResult = strconv.FormatFloat(3.14, 'f', -1, 64)
- actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue("param_float_value_only").(float64),
'f', -1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue(paramName).(float64),
'f', -1, 64)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_string_type_and_value_only should be foo
+ paramName = "param_string_type_and_value_only"
expectedResult = "foo"
- actualResult =
action.Action.Parameters.GetValue("param_string_type_and_value_only").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_string_type_only should be ""
- actualResult =
action.Action.Parameters.GetValue("param_string_type_only").(string)
- assert.Empty(t, actualResult, "Expected empty string but got " +
actualResult)
+ paramName = "param_string_type_only"
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Empty(t, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_integer_type_only should be 0
+ paramName = "param_integer_type_only"
expectedResult = strconv.FormatInt(0, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_integer_type_only").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_float_type_only should be 0
+ paramName = "param_float_type_only"
expectedResult = strconv.FormatFloat(0.0, 'f', -1, 64)
- actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue("param_float_type_only").(float64),
'f', -1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue(paramName).(float64),
'f', -1, 64)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_string_with_default should be "bar"
+ paramName = "param_string_with_default"
expectedResult = "bar"
- actualResult =
action.Action.Parameters.GetValue("param_string_with_default").(string)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult = action.Action.Parameters.GetValue(paramName).(string)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_integer_with_default should be -1
+ paramName = "param_integer_with_default"
expectedResult = strconv.FormatInt(-1, 10)
- actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue("param_integer_with_default").(int)),
10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatInt(int64(action.Action.Parameters.GetValue(paramName).(int)), 10)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
// param_float_with_default should be 2.9
+ paramName = "param_float_with_default"
expectedResult = strconv.FormatFloat(2.9, 'f', -1, 64)
- actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue("param_float_with_default").(float64),
'f', -1, 64)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ actualResult =
strconv.FormatFloat(action.Action.Parameters.GetValue(paramName).(float64),
'f', -1, 64)
+ assert.Equal(t, expectedResult, actualResult,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, paramName))
}
}
@@ -893,28 +940,28 @@ func TestComposeActionsForWebActions(t *testing.T) {
// Test 16: validate manifest_parser.ResolveParameter() method
func TestResolveParameterForMultiLineParams(t *testing.T) {
- p := "name"
+ paramName := "name"
v := "foo"
y := reflect.TypeOf(v).Name() // y := string
d := "default_name"
// type string - value only param
param1 := Parameter{Value: v, multiline: true}
- r1, _ := ResolveParameter(p, ¶m1, "")
- assert.Equal(t, v, r1, "Expected value " + v + " but got " + r1.(string))
- assert.IsType(t, v, r1, "Expected parameter %v of type %T but found %T",
p, v, r1)
+ r1, _ := ResolveParameter(paramName, ¶m1, "")
+ assert.Equal(t, v, r1,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH,paramName))
+ assert.IsType(t, v, r1,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH,paramName))
// type string - type and value only param
param2 := Parameter{Type: y, Value: v, multiline: true}
- r2, _ := ResolveParameter(p, ¶m2, "")
- assert.Equal(t, v, r2, "Expected value " + v + " but got " + r2.(string))
- assert.IsType(t, v, r2, "Expected parameter %v of type %T but found %T",
p, v, r2)
+ r2, _ := ResolveParameter(paramName, ¶m2, "")
+ assert.Equal(t, v, r2,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH,paramName))
+ assert.IsType(t, v, r2,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH,paramName))
// type string - type, no value, but default value param
param3 := Parameter{Type: y, Default: d, multiline: true}
- r3, _ := ResolveParameter(p, ¶m3, "")
- assert.Equal(t, d, r3, "Expected value " + d + " but got " + r3.(string))
- assert.IsType(t, d, r3, "Expected parameter %v of type %T but found %T",
p, d, r3)
+ r3, _ := ResolveParameter(paramName, ¶m3, "")
+ assert.Equal(t, d, r3,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH,paramName))
+ assert.IsType(t, d, r3,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH,paramName))
// type string - type and value only param
// type is "string" and value is of type "int"
@@ -924,13 +971,13 @@ func TestResolveParameterForMultiLineParams(t *testing.T)
{
// in this case, ResolveParameter returns value of type int
v1 := 11
param4 := Parameter{Type: y, Value: v1, multiline: true}
- r4, _ := ResolveParameter(p, ¶m4, "")
- assert.Equal(t, v1, r4, "Expected value " + strconv.FormatInt(int64(v1),
10) + " but got " + strconv.FormatInt(int64(r4.(int)), 10))
- assert.IsType(t, v1, r4, "Expected parameter %v of type %T but found %T",
p, v1, r4)
+ r4, _ := ResolveParameter(paramName, ¶m4, "")
+ assert.Equal(t, v1, r4,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH,paramName))
+ assert.IsType(t, v1, r4,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH,paramName))
// type invalid - type only param
param5 := Parameter{Type: "invalid", multiline: true}
- _, err := ResolveParameter(p, ¶m5, "")
+ _, err := ResolveParameter(paramName, ¶m5, "")
assert.NotNil(t, err, "Expected error saying Invalid type for parameter")
switch errorType := err.(type) {
default:
@@ -941,8 +988,9 @@ func TestResolveParameterForMultiLineParams(t *testing.T) {
// type none - param without type, without value, and without default value
param6 := Parameter{multiline: true}
- r6, _ := ResolveParameter("none", ¶m6, "")
- assert.Empty(t, r6, "Expected default value of empty string but found " +
r6.(string))
+ paramName = "none"
+ r6, _ := ResolveParameter(paramName, ¶m6, "")
+ assert.Empty(t, r6,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH,paramName))
}
@@ -954,37 +1002,32 @@ func TestParseManifestForJSONParams(t *testing.T) {
m, err := NewYAMLParser().ParseManifest(manifestFile)
if err != nil {
- assert.Fail(t, "Failed to parse manifest: " + manifestFile )
+ assert.Fail(t, fmt.Sprintf(TEST_ERROR_MANIFEST_PARSE_FAILURE,
manifestFile))
}
// validate package name should be "validate"
packageName := "validate_json"
actionName := "validate_json_params"
- expectedActionsCount := 1
-
- assert.NotNil(t, m.Packages[packageName],
- "Expected package named "+ packageName + " but got none")
// validate this package contains one action
actualActionsCount := len(m.Packages[packageName].Actions)
- assert.Equal(t, expectedActionsCount, actualActionsCount,
- "Expected " + string(expectedActionsCount) + " but got " +
string(actualActionsCount))
+ assert.Equal(t, 1, actualActionsCount, TEST_MSG_ACTION_NUMBER_MISMATCH)
if action, ok := m.Packages[packageName].Actions[actionName]; ok {
- // validate location/function of an action to be
"actions/dump_params.js"
+ // test Action function's path
expectedResult := "actions/dump_params.js"
actualResult := action.Function
- assert.Equal(t, expectedResult, actualResult, "Expected action
function " + expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_ACTION_FUNCTION_PATH_MISMATCH)
// validate runtime of an action to be "nodejs:6"
expectedResult = "nodejs:6"
actualResult = action.Runtime
- assert.Equal(t, expectedResult, actualResult, "Expected action runtime
" + expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_ACTION_FUNCTION_RUNTIME_MISMATCH)
// validate the number of inputs to this action
expectedResult = strconv.FormatInt(6, 10)
actualResult = strconv.FormatInt(int64(len(action.Inputs)), 10)
- assert.Equal(t, expectedResult, actualResult, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult, actualResult,
TEST_MSG_PARAMETER_NUMBER_MISMATCH)
// validate inputs to this action
for input, param := range action.Inputs {
@@ -994,27 +1037,27 @@ func TestParseManifestForJSONParams(t *testing.T) {
case "member1":
actualResult1 := param.Value.(string)
expectedResult1 := "{ \"name\": \"Sam\", \"place\": \"Shire\"
}"
- assert.Equal(t, expectedResult1, actualResult1, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult1, actualResult1,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, input))
case "member2":
actualResult2 := param.Value.(map[interface{}]interface{})
expectedResult2 := map[interface{}]interface{}{"name": "Sam",
"place": "Shire"}
- assert.Equal(t, expectedResult2, actualResult2, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult2, actualResult2,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, input))
case "member3":
actualResult3 := param.Value.(map[interface{}]interface{})
expectedResult3 := map[interface{}]interface{}{"name":
"Elrond", "place": "Rivendell"}
- assert.Equal(t, expectedResult3, actualResult3, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult3, actualResult3,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, input))
case "member4":
actualResult4 := param.Value.(map[interface{}]interface{})
expectedResult4 := map[interface{}]interface{}{"name":
"Gimli", "place": "Gondor", "age": 139, "children":
map[interface{}]interface{}{ "<none>": "<none>" }}
- assert.Equal(t, expectedResult4, actualResult4, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult4, actualResult4,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, input))
case "member5":
actualResult5 := param.Value.(map[interface{}]interface{})
expectedResult5 := map[interface{}]interface{}{"name":
"Gloin", "place": "Gondor", "age": 235, "children":
map[interface{}]interface{}{ "Gimli": "Son" }}
- assert.Equal(t, expectedResult5, actualResult5, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult5, actualResult5,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, input))
case "member6":
actualResult6 := param.Value.(map[interface{}]interface{})
expectedResult6 := map[interface{}]interface{}{"name":
"Frodo", "place": "Undying Lands", "items": []interface{}{"Sting", "Mithril
mail"}}
- assert.Equal(t, expectedResult6, actualResult6, "Expected " +
expectedResult + " but got " + actualResult)
+ assert.Equal(t, expectedResult6, actualResult6,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_VALUE_MISMATCH, input))
}
}
@@ -1024,7 +1067,7 @@ func TestParseManifestForJSONParams(t *testing.T) {
case "fellowship":
expectedType := "json"
actualType := param.Type
- assert.Equal(t, expectedType, actualType, "Expected Type: " +
expectedType + ", but got: " + actualType)
+ assert.Equal(t, expectedType, actualType,
fmt.Sprintf(TEST_MSG_ACTION_PARAMETER_TYPE_MISMATCH, output))
}
}
}
diff --git a/parsers/yamlparser.go b/parsers/yamlparser.go
index 172fa2c..f6e352c 100644
--- a/parsers/yamlparser.go
+++ b/parsers/yamlparser.go
@@ -27,22 +27,22 @@ func NewYAMLParser() *YAMLParser {
return &YAMLParser{}
}
-type ParseYaml interface {
- Unmarshal(input []byte, deploy *YAML) error
- Marshal(manifest *YAML) (output []byte, err error)
-
- //Compose Package entity according to yaml content
- ComposePackages(manifestpath string) ([]*whisk.Package, error)
-
- // Compose Action entities according to yaml content
- ComposeActions(manifestpath string) ([]*whisk.Action, error)
-
- // Compose Trigger entities according to deployment and manifest yaml
content
- ComposeTriggers(manifestpath string, deploymentpath string)
([]*whisk.Trigger, error)
-
- // Compose Rule entities according to yaml content
- ComposeRules(manifestpath string) ([]*whisk.Rule, error)
-}
+//type ParseYaml interface {
+// Unmarshal(input []byte, deploy *YAML) error
+// Marshal(manifest *YAML) (output []byte, err error)
+//
+// //Compose Package entity according to yaml content
+// ComposePackages(manifestpath string) ([]*whisk.Package, error)
+//
+// // Compose Action entities according to yaml content
+// ComposeActions(manifestpath string) ([]*whisk.Action, error)
+//
+// // Compose Trigger entities according to deployment and manifest yaml
content
+// ComposeTriggers(manifestpath string, deploymentpath string)
([]*whisk.Trigger, error)
+//
+// // Compose Rule entities according to yaml content
+// ComposeRules(manifestpath string) ([]*whisk.Rule, error)
+//}
type YAMLParser struct {
manifests []*YAML
diff --git a/tests/dat/manifest_hello_java_jar.yaml
b/tests/dat/manifest_hello_java_jar.yaml
new file mode 100644
index 0000000..8a3a1d1
--- /dev/null
+++ b/tests/dat/manifest_hello_java_jar.yaml
@@ -0,0 +1,7 @@
+package:
+ name: helloworld
+ actions:
+ helloJava:
+ function: actions/hello.jar
+ runtime: java
+ main: Hello
diff --git a/tests/dat/manifest_hello_nodejs.yaml
b/tests/dat/manifest_hello_nodejs.yaml
new file mode 100644
index 0000000..82bce71
--- /dev/null
+++ b/tests/dat/manifest_hello_nodejs.yaml
@@ -0,0 +1,6 @@
+package:
+ name: helloworld
+ actions:
+ helloNodejs:
+ function: actions/hello.js
+ runtime: nodejs:6
diff --git a/tests/dat/manifest_hello_nodejs_with_params.yaml
b/tests/dat/manifest_hello_nodejs_with_params.yaml
new file mode 100644
index 0000000..c23f811
--- /dev/null
+++ b/tests/dat/manifest_hello_nodejs_with_params.yaml
@@ -0,0 +1,9 @@
+package:
+ name: helloworld
+ actions:
+ helloWithParams:
+ function: actions/hello-with-params.js
+ runtime: nodejs:6
+ inputs:
+ name: Amy
+ place: Paris
diff --git a/tests/dat/manifest_hello_python.yaml
b/tests/dat/manifest_hello_python.yaml
new file mode 100644
index 0000000..527d838
--- /dev/null
+++ b/tests/dat/manifest_hello_python.yaml
@@ -0,0 +1,6 @@
+package:
+ name: helloworld
+ actions:
+ helloPython:
+ function: actions/hello.py
+ runtime: python
diff --git a/tests/dat/manifest_hello_swift.yaml
b/tests/dat/manifest_hello_swift.yaml
new file mode 100644
index 0000000..aedcb1d
--- /dev/null
+++ b/tests/dat/manifest_hello_swift.yaml
@@ -0,0 +1,6 @@
+package:
+ name: helloworld
+ actions:
+ helloSwift:
+ function: actions/hello.swift
+ runtime: swift
diff --git a/tests/dat/manifest_invalid_package_missing.yaml
b/tests/dat/manifest_invalid_package_missing.yaml
new file mode 100644
index 0000000..f2480d6
--- /dev/null
+++ b/tests/dat/manifest_invalid_package_missing.yaml
@@ -0,0 +1,6 @@
+ actions:
+ helloNodejs:
+ function: actions/hello.js
+ runtime: nodejs:6
+ helloJava:
+ function: actions/hello.java
diff --git a/wskderrors/wskdeployerror_test.go
b/wskderrors/wskdeployerror_test.go
index 5c7507d..8bf153e 100644
--- a/wskderrors/wskdeployerror_test.go
+++ b/wskderrors/wskdeployerror_test.go
@@ -171,11 +171,6 @@ func TestCustomErrorOutputFormat(t *testing.T) {
*/
// TODO add a unit test once we re-factor error related modules into a
new package
- // to avoid cyclic dependency errors in GoLang.
- //manifestFile := "../tests/dat/manifest_bad_yaml_invalid_comment.yaml"
- //m, err := parsers.NewYAMLParser().ParseManifest(manifestFile)
- //fmt.Println(err)
-
// TODO - use actual YAML files to generate actual errors for
comparison with expected error output
//var TEST_LINES = []string{"40", STR_UNKNOWN, "123"}
//var TEST_MESSAGES = []string{"did not find expected key", "did not
find expected ',' or ']'", "found duplicate %YAML directive"}
--
To stop receiving notification emails like this one, please contact
['"[email protected]" <[email protected]>'].
