You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@openwhisk.apache.org by GitBox <gi...@apache.org> on 2017/11/16 18:53:25 UTC
[GitHub] houshengbo closed pull request #632: Add unit tests for wskdeploy custom error types.
houshengbo closed pull request #632: Add unit tests for wskdeploy custom error types.
URL: https://github.com/apache/incubator-openwhisk-wskdeploy/pull/632
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/cmd/root.go b/cmd/root.go
index 4831c7b..df579cf 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -180,7 +180,7 @@ 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})
- return utils.NewErrorManifestFileNotFound(errString)
+ return utils.NewErrorManifestFileNotFound(projectPath, errString)
}
whisk.Debug(whisk.DbgInfo, stdout)
}
@@ -239,7 +239,7 @@ func Deploy() error {
errString := wski18n.T("Manifest file is not found at the path [{{.filePath}}].\n",
map[string]interface{}{"filePath": utils.Flags.ManifestPath})
whisk.Debug(whisk.DbgError, errString)
- return utils.NewErrorManifestFileNotFound(errString)
+ return utils.NewErrorManifestFileNotFound(utils.Flags.ManifestPath, errString)
}
}
@@ -273,7 +273,7 @@ func Undeploy() 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})
- return utils.NewErrorManifestFileNotFound(errString)
+ return utils.NewErrorManifestFileNotFound(projectPath, errString)
}
whisk.Debug(whisk.DbgInfo, stdout)
}
@@ -330,6 +330,6 @@ func Undeploy() error {
errString := wski18n.T("Manifest file is not found at the path [{{.filePath}}].\n",
map[string]interface{}{"filePath": utils.Flags.ManifestPath})
whisk.Debug(whisk.DbgError, errString)
- return utils.NewErrorManifestFileNotFound(errString)
+ return utils.NewErrorManifestFileNotFound(utils.Flags.ManifestPath, errString)
}
}
diff --git a/deployers/deploymentreader.go b/deployers/deploymentreader.go
index 21dd39e..af99451 100644
--- a/deployers/deploymentreader.go
+++ b/deployers/deploymentreader.go
@@ -145,7 +145,8 @@ func (reader *DeploymentReader) bindPackageInputsAndAnnotations() error {
}
if !keyExistsInManifest {
err := wski18n.T("Annotation key \"" + name + "\" does not exist in manifest file but specified in deployment file.")
- return utils.NewYAMLFormatError(err)
+ // TODO see if we can pass in the YAML file path on first parameter
+ return utils.NewYAMLFileFormatError(utils.LINE_UNKNOWN, err)
}
}
}
@@ -234,7 +235,8 @@ func (reader *DeploymentReader) bindActionInputsAndAnnotations() error {
}
if !keyExistsInManifest {
err := wski18n.T("Annotation key \"" + name + "\" does not exist in manifest file but specified in deployment file.")
- return utils.NewYAMLFormatError(err)
+ // TODO see if we can pass in the YAML file path on first parameter
+ return utils.NewYAMLFileFormatError(utils.LINE_UNKNOWN, err)
}
}
}
@@ -320,7 +322,8 @@ func (reader *DeploymentReader) bindTriggerInputsAndAnnotations() error {
}
if !keyExistsInManifest {
err := wski18n.T("Annotation key \"" + name + "\" does not exist in manifest file but specified in deployment file.")
- return utils.NewYAMLFormatError(err)
+ // TODO see if we can pass in the YAML file path on first parameter
+ return utils.NewYAMLFileFormatError(utils.LINE_UNKNOWN, err)
}
}
}
diff --git a/deployers/deploymentreader_test.go b/deployers/deploymentreader_test.go
index a4a518e..2c2aeb1 100644
--- a/deployers/deploymentreader_test.go
+++ b/deployers/deploymentreader_test.go
@@ -45,6 +45,7 @@ func TestDeploymentReader_HandleYaml(t *testing.T) {
assert.NotNil(t, dr.DeploymentDescriptor.GetProject().Packages["GitHubCommits"], "DeploymentReader handle deployment yaml failed.")
}
+// TODO remove this unused test?
func TestDeployerCheck(t *testing.T) {
sd := NewServiceDeployer()
sd.DeploymentPath = "../tests/usecases/badyaml/deployment.yaml"
diff --git a/deployers/filesystemreader.go b/deployers/filesystemreader.go
index 0635bc5..f99a379 100644
--- a/deployers/filesystemreader.go
+++ b/deployers/filesystemreader.go
@@ -56,7 +56,7 @@ func (reader *FileSystemReader) ReadProjectDirectory(manifest *parsers.YAML) ([]
if fpath != reader.serviceDeployer.ProjectPath {
pathCount, err := reader.getFilePathCount(fpath)
if err != nil {
- return utils.NewYAMLFileReadError(err.Error())
+ return utils.NewFileReadError(fpath, err.Error())
}
if !f.IsDir() {
@@ -76,7 +76,7 @@ func (reader *FileSystemReader) ReadProjectDirectory(manifest *parsers.YAML) ([]
if foundFile == true {
_, action, err := reader.CreateActionFromFile(reader.serviceDeployer.ManifestPath, fpath)
if err != nil {
- return utils.NewYAMLFileReadError(err.Error())
+ return utils.NewFileReadError(fpath, err.Error())
}
var record utils.ActionRecord
@@ -127,7 +127,7 @@ func (reader *FileSystemReader) CreateActionFromFile(manipath, filePath string)
dat, err := new(utils.ContentReader).LocalReader.ReadLocal(filePath)
if err != nil {
- return name, action, utils.NewYAMLFileReadError(err.Error())
+ return name, action, utils.NewFileReadError(filePath, err.Error())
}
action.Exec = new(whisk.Exec)
diff --git a/deployers/manifestreader.go b/deployers/manifestreader.go
index 1950ca8..cf6ced1 100644
--- a/deployers/manifestreader.go
+++ b/deployers/manifestreader.go
@@ -46,7 +46,7 @@ func (deployer *ManifestReader) ParseManifest() (*parsers.YAML, *parsers.YAMLPar
manifest, err := manifestParser.ParseManifest(dep.ManifestPath)
if err != nil {
- return manifest, manifestParser, utils.NewYAMLFileReadError(err.Error())
+ return manifest, manifestParser, utils.NewFileReadError(dep.ManifestPath, err.Error())
}
return manifest, manifestParser, nil
}
@@ -54,7 +54,7 @@ func (deployer *ManifestReader) ParseManifest() (*parsers.YAML, *parsers.YAMLPar
func (reader *ManifestReader) InitRootPackage(manifestParser *parsers.YAMLParser, manifest *parsers.YAML, ma whisk.KeyValue) error {
packages, err := manifestParser.ComposeAllPackages(manifest, reader.serviceDeployer.ManifestPath, ma)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifest.Filepath, err.Error())
}
reader.SetPackage(packages)
@@ -65,64 +65,66 @@ func (reader *ManifestReader) InitRootPackage(manifestParser *parsers.YAMLParser
func (deployer *ManifestReader) HandleYaml(sdeployer *ServiceDeployer, manifestParser *parsers.YAMLParser, manifest *parsers.YAML, ma whisk.KeyValue) error {
var err error
+ var manifestName = manifest.Filepath
+
deps, err := manifestParser.ComposeDependenciesFromAllPackages(manifest, deployer.serviceDeployer.ProjectPath, deployer.serviceDeployer.ManifestPath)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
actions, err := manifestParser.ComposeActionsFromAllPackages(manifest, deployer.serviceDeployer.ManifestPath, ma)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
sequences, err := manifestParser.ComposeSequencesFromAllPackages(deployer.serviceDeployer.ClientConfig.Namespace, manifest, ma)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
triggers, err := manifestParser.ComposeTriggersFromAllPackages(manifest, deployer.serviceDeployer.ManifestPath, ma)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
rules, err := manifestParser.ComposeRulesFromAllPackages(manifest)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
apis, err := manifestParser.ComposeApiRecordsFromAllPackages(manifest)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
err = deployer.SetDependencies(deps)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
err = deployer.SetActions(actions)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
err = deployer.SetSequences(sequences)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
err = deployer.SetTriggers(triggers)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
err = deployer.SetRules(rules)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
err = deployer.SetApis(apis)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(manifestName, err.Error())
}
return nil
@@ -142,7 +144,7 @@ func (reader *ManifestReader) SetDependencies(deps map[string]utils.DependencyRe
gitReader := utils.NewGitReader(depName, dep)
err := gitReader.CloneDependency()
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(depName, err.Error())
}
} else {
// TODO: we should do a check to make sure this dependency is compatible with an already installed one.
@@ -225,7 +227,7 @@ func (reader *ManifestReader) SetActions(actions []utils.ActionRecord) error {
err := reader.checkAction(existAction)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewFileReadError(manifestAction.Filepath, err.Error())
}
} else {
@@ -236,7 +238,7 @@ func (reader *ManifestReader) SetActions(actions []utils.ActionRecord) error {
// not a new action so update the action in the package
err := reader.checkAction(manifestAction)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewFileReadError(manifestAction.Filepath, err.Error())
}
reader.serviceDeployer.Deployment.Packages[manifestAction.Packagename].Actions[manifestAction.Action.Name] = manifestAction
}
@@ -245,6 +247,7 @@ func (reader *ManifestReader) SetActions(actions []utils.ActionRecord) error {
return nil
}
+// TODO create named errors
func (reader *ManifestReader) checkAction(action utils.ActionRecord) error {
if action.Filepath == "" {
return errors.New("Error: Action " + action.Action.Name + " has no source code location set.")
@@ -294,7 +297,8 @@ func (reader *ManifestReader) SetSequences(actions []utils.ActionRecord) error {
// not a new action so update the action in the package
err := reader.checkAction(seqAction)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ // TODO() Need a better error type here
+ return utils.NewFileReadError(seqAction.Filepath, err.Error())
}
reader.serviceDeployer.Deployment.Packages[seqAction.Packagename].Sequences[seqAction.Action.Name] = seqAction
}
diff --git a/deployers/servicedeployer.go b/deployers/servicedeployer.go
index 77cda4b..7bcb74d 100644
--- a/deployers/servicedeployer.go
+++ b/deployers/servicedeployer.go
@@ -132,13 +132,16 @@ func (deployer *ServiceDeployer) ConstructDeploymentPlan() error {
// OpenWhisk entities are annotated with Project Name and therefore
// Project Name in manifest/deployment file is mandatory for managed deployments
if deployer.ProjectName == "" {
- return utils.NewYAMLFormatError("Project name in manifest file is mandatory for managed deployments")
+ // TODO see if we can pass in the Deployment file path on first parameter
+ // TODO see if we can move string to translation file.
+ return utils.NewYAMLFileFormatError(utils.LINE_UNKNOWN, "Project name in manifest file is mandatory for managed deployments")
}
// Every OpenWhisk entity in the manifest file will be annotated with:
//managed: '{"__OW__PROJECT__NAME": <name>, "__OW__PROJECT_HASH": <hash>, "__OW__FILE": <path>}'
deployer.ManagedAnnotation, err = utils.GenerateManagedAnnotation(deployer.ProjectName, manifest.Filepath)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ // TODO see if we can pass in the YAML file path on first parameter
+ return utils.NewYAMLFileFormatError(utils.LINE_UNKNOWN, err.Error())
}
}
@@ -192,7 +195,7 @@ func (deployer *ServiceDeployer) ConstructDeploymentPlan() error {
errorString := wski18n.T("The name of the project/application {{.projectNameDeploy}} in deployment file at [{{.deploymentFile}}] does not match the name of the project/application {{.projectNameManifest}}} in manifest file at [{{.manifestFile}}].",
map[string]interface{}{"projectNameDeploy": projectNameDeploy, "deploymentFile": deployer.DeploymentPath,
"projectNameManifest": projectName, "manifestFile": deployer.ManifestPath})
- return utils.NewYAMLFormatError(errorString)
+ return utils.NewYAMLFileFormatError(manifest.Filepath, errorString)
}
}
if err := deploymentReader.BindAssets(); err != nil {
@@ -268,7 +271,7 @@ func (deployer *ServiceDeployer) ConstructUnDeploymentPlan() (*DeploymentProject
errorString := wski18n.T("The name of the project/application {{.projectNameDeploy}} in deployment file at [{{.deploymentFile}}] does not match the name of the application {{.projectNameManifest}}} in manifest file at [{{.manifestFile}}].",
map[string]interface{}{"projectNameDeploy": projectNameDeploy, "deploymentFile": deployer.DeploymentPath,
"projectNameManifest": projectName, "manifestFile": deployer.ManifestPath})
- return deployer.Deployment, utils.NewYAMLFormatError(errorString)
+ return deployer.Deployment, utils.NewYAMLFileFormatError(manifest.Filepath, errorString)
}
}
diff --git a/parsers/deploy_parser.go b/parsers/deploy_parser.go
index 49c6add..a751737 100644
--- a/parsers/deploy_parser.go
+++ b/parsers/deploy_parser.go
@@ -35,7 +35,7 @@ func (dm *YAMLParser) ParseDeployment(deploymentPath string) (*YAML, error) {
dplyyaml := YAML{}
content, err := new(utils.ContentReader).LocalReader.ReadLocal(deploymentPath)
if err != nil {
- return &dplyyaml, utils.NewYAMLFileReadError(err.Error())
+ return &dplyyaml, utils.NewFileReadError(deploymentPath, err.Error())
}
err = dm.unmarshalDeployment(content, &dplyyaml)
if err != nil {
@@ -56,7 +56,7 @@ func (dm *YAMLParser) convertErrorToLinesMsgs(errorString string) (lines []strin
} else {
errorMsg = strs[i]
}
- lines = append(lines, utils.UNKNOWN)
+ lines = append(lines, utils.LINE_UNKNOWN)
msgs = append(msgs, strings.TrimSpace(errorMsg))
}
return
diff --git a/parsers/manifest_parser.go b/parsers/manifest_parser.go
index b13bcb8..85bab5e 100644
--- a/parsers/manifest_parser.go
+++ b/parsers/manifest_parser.go
@@ -41,7 +41,7 @@ func ReadOrCreateManifest() (*YAML, error) {
dat, _ := ioutil.ReadFile(utils.ManifestFileNameYaml)
err := NewYAMLParser().Unmarshal(dat, &maniyaml)
if err != nil {
- return &maniyaml, utils.NewYAMLFileReadError(err.Error())
+ return &maniyaml, utils.NewFileReadError(utils.ManifestFileNameYaml, err.Error())
}
}
return &maniyaml, nil
@@ -51,12 +51,12 @@ func ReadOrCreateManifest() (*YAML, error) {
func Write(manifest *YAML, filename string) error {
output, err := NewYAMLParser().marshal(manifest)
if err != nil {
- return utils.NewYAMLFormatError(err.Error())
+ return utils.NewYAMLFileFormatError(filename, err.Error())
}
f, err := os.Create(filename)
if err != nil {
- return utils.NewYAMLFileReadError(err.Error())
+ return utils.NewFileReadError(filename, err.Error())
}
defer f.Close()
@@ -87,7 +87,7 @@ func (dm *YAMLParser) ParseManifest(manifestPath string) (*YAML, error) {
content, err := utils.Read(manifestPath)
if err != nil {
- return &maniyaml, utils.NewYAMLFileReadError(err.Error())
+ return &maniyaml, utils.NewFileReadError(manifestPath, err.Error())
}
err = mm.Unmarshal(content, &maniyaml)
diff --git a/parsers/manifest_parser_test.go b/parsers/manifest_parser_test.go
index 3b9731d..cb79e1a 100644
--- a/parsers/manifest_parser_test.go
+++ b/parsers/manifest_parser_test.go
@@ -938,7 +938,7 @@ func TestResolveParameterForMultiLineParams(t *testing.T) {
switch errorType := err.(type) {
default:
assert.Fail(t, "Wrong error type received: We are expecting ParserErr.")
- case *utils.YAMLParserErr:
+ case *utils.YAMLParserError:
assert.Equal(t, expectedErr.Message, errorType.Message,
"Expected error " + expectedErr.Message + " but found " + errorType.Message)
}
diff --git a/parsers/parameters.go b/parsers/parameters.go
index 69cb467..1767ec8 100644
--- a/parsers/parameters.go
+++ b/parsers/parameters.go
@@ -23,33 +23,41 @@ import (
"github.com/apache/incubator-openwhisk-wskdeploy/utils"
)
-
// TODO(): Support other valid Package Manifest types
// TODO(): i.e., timestamp, version, string256, string64, string16
// TODO(): Support JSON schema validation for type: json
// TODO(): Support OpenAPI schema validation
+const (
+ STRING string = "string"
+ INTEGER string = "integer"
+ FLOAT string = "float"
+ BOOLEAN string = "boolean"
+ JSON string = "json"
+)
var validParameterNameMap = map[string]string{
- "string": "string",
- "int": "integer",
- "float": "float",
- "bool": "boolean",
- "int8": "integer",
- "int16": "integer",
- "int32": "integer",
- "int64": "integer",
- "float32": "float",
- "float64": "float",
- "json": "json",
- "map": "json",
+ STRING: STRING,
+ FLOAT: FLOAT,
+ BOOLEAN: BOOLEAN,
+ INTEGER: INTEGER,
+ "int": INTEGER,
+ "bool": BOOLEAN,
+ "int8": INTEGER,
+ "int16": INTEGER,
+ "int32": INTEGER,
+ "int64": INTEGER,
+ "float32": FLOAT,
+ "float64": FLOAT,
+ JSON: JSON,
+ "map": JSON,
}
var typeDefaultValueMap = map[string]interface{}{
- "string": "",
- "integer": 0,
- "float": 0.0,
- "boolean": false,
- "json": make(map[string]interface{}),
+ STRING: "",
+ INTEGER: 0,
+ FLOAT: 0.0,
+ BOOLEAN: false,
+ JSON: make(map[string]interface{}),
// TODO() Support these types + their validation
// timestamp
// null
@@ -73,12 +81,24 @@ func getTypeDefaultValue(typeName string) interface{} {
if val, ok := typeDefaultValueMap[typeName]; ok {
return val
} else {
- // TODO() throw an error "type not found"
+ // TODO() throw an error "type not found" InvalidParameterType
}
return nil
}
-func ResolveParamTypeFromValue(name string, value interface{}, filePath string) (string, error) {
+
+/*
+ ResolveParamTypeFromValue Resolves the Parameter's data type from its actual value.
+
+ Inputs:
+ - paramName: name of the parameter for error reporting
+ - filepath: the path, including name, of the YAML file which contained the parameter for error reporting
+ - value: the parameter value to resolve
+
+ Returns:
+ - (string) parameter type name as a string
+ */
+func ResolveParamTypeFromValue(paramName string, value interface{}, filePath string) (string, error) {
// Note: 'string' is the default type if not specified and not resolvable.
var paramType string = "string"
var err error = nil
@@ -93,9 +113,7 @@ func ResolveParamTypeFromValue(name string, value interface{}, filePath string)
} else {
// raise an error if parameter's value is not a known type
- // TODO() - move string to i18n
- msgs := []string{"Parameter [" + name + "] has a value that is not a known type. [" + actualType + "]"}
- err = utils.NewYAMLParserErr(filePath, nil, msgs)
+ err = utils.NewInvalidParameterTypeError(filePath, paramName, actualType)
}
}
return paramType, err
@@ -110,8 +128,16 @@ func ResolveParamTypeFromValue(name string, value interface{}, filePath string)
- detects if the parameter value contains the name of a valid OpenWhisk parameter types. if so, the
- param.Type is set to detected OpenWhisk parameter type.
- param.Value is set to the zero (default) value for that OpenWhisk parameter type.
+
+ Inputs:
+ - filePath: the path, including name, of the YAML file which contained the parameter for error reporting
+ - paramName: name of the parameter for error reporting
+ - param: pointer to Parameter structure being resolved
+
+ Returns:
+ - (interface{}) the parameter's resolved value
*/
-func resolveSingleLineParameter(paramName string, param *Parameter, filePath string) (interface{}, error) {
+func resolveSingleLineParameter(filePath string, paramName string, param *Parameter) (interface{}, error) {
var errorParser error
if !param.multiline {
@@ -146,8 +172,16 @@ func resolveSingleLineParameter(paramName string, param *Parameter, filePath str
- uses param.Default as param.Value if param.Value is not provided
- uses the actual param.Value data type for param.type if param.Type is not provided
+ Inputs:
+ - filepath: the path, including name, of the YAML file which contained the parameter for error reporting
+ - paramName: name of the parameter for error reporting
+ - param: pointer to Parameter structure being resolved
+
+ Returns:
+ - (interface{}) the parameter's resolved value
+
*/
-func resolveMultiLineParameter(paramName string, param *Parameter, filePath string) (interface{}, error) {
+func resolveMultiLineParameter(filePath string, paramName string, param *Parameter) (interface{}, error) {
var errorParser error
if param.multiline {
@@ -193,10 +227,20 @@ func resolveMultiLineParameter(paramName string, param *Parameter, filePath stri
This function handles the forms JSON data appears in:
1) a string containing JSON, which needs to be parsed into map[string]interface{}
2) is a map of JSON (but not a map[string]interface{}
+
+ Inputs:
+ - paramName: name of the parameter for error reporting
+ - filePath: the path, including name, of the YAML file which contained the parameter for error reporting
+ - param: pointer to Parameter structure being resolved
+ - value: the current actual value of the parameter being resolved
+
+ Returns:
+ - (interface{}) the parameter's resolved value
*/
-func resolveJSONParameter(paramName string, param *Parameter, value interface{}, filePath string) (interface{}, error) {
+func resolveJSONParameter(filePath string, paramName string, param *Parameter, value interface{}) (interface{}, error) {
var errorParser error
+ // TODO() Is the "value" function parameter really needed with the current logic (use param.Value)?
if param.Type == "json" {
// Case 1: if user set parameter type to 'json' and the value's type is a 'string'
if str, ok := value.(string); ok {
@@ -218,10 +262,13 @@ func resolveJSONParameter(paramName string, param *Parameter, value interface{},
//fmt.Printf("EXIT: Parameter [%s] type=[%v] value=[%v]\n", paramName, param.Type, temp)
return temp, errorParser
}
- } // else TODO{}
+ } else{
+ errorParser = utils.NewParameterTypeMismatchError(filePath, paramName, JSON, param.Type)
+ }
+
} else {
msgs := []string{"Parameter [" + paramName + "] is not JSON format."}
- return param.Value, utils.NewYAMLParserErr(filePath, nil, msgs)
+ errorParser = utils.NewYAMLParserErr(filePath, nil, msgs)
}
return param.Value, errorParser
@@ -240,25 +287,30 @@ func resolveJSONParameter(paramName string, param *Parameter, value interface{},
Note: parameter values may set later (overridden) by an (optional) Deployment file
+ Inputs:
+ - paramName: name of the parameter for error reporting
+ - filepath: the path, including name, of the YAML file which contained the parameter for error reporting
+ - param: pointer to Parameter structure being resolved
+
+ Returns:
+ - (interface{}) the parameter's resolved value
*/
func ResolveParameter(paramName string, param *Parameter, filePath string) (interface{}, error) {
var errorParser error
- // default parameter value to empty string
+ // default resolved parameter value to empty string
var value interface{} = ""
// Trace Parameter struct before any resolution
//dumpParameter(paramName, param, "BEFORE")
// Parameters can be single OR multi-line declarations which must be processed/validated differently
+ // Regardless, the following functions will assure that param.Value and param.Type are correctly set
if !param.multiline {
-
- // This function will assure that param.Value and param.Type are correctly set
- value, errorParser = resolveSingleLineParameter(paramName, param, filePath)
+ value, errorParser = resolveSingleLineParameter(filePath, paramName, param)
} else {
-
- value, errorParser = resolveMultiLineParameter(paramName, param, filePath)
+ value, errorParser = resolveMultiLineParameter(filePath, paramName, param)
}
// String value pre-processing (interpolation)
@@ -272,7 +324,7 @@ func ResolveParameter(paramName string, param *Parameter, filePath string) (inte
// JSON - Handle both cases, where value 1) is a string containing JSON, 2) is a map of JSON
if param.Type == "json" {
- value, errorParser = resolveJSONParameter(paramName, param, value, filePath)
+ value, errorParser = resolveJSONParameter(filePath, paramName, param, value)
}
// Default value to zero value for the Type
diff --git a/utils/errorhandlers.go b/utils/errorhandlers.go
index 0506ca4..e566c88 100644
--- a/utils/errorhandlers.go
+++ b/utils/errorhandlers.go
@@ -18,35 +18,12 @@
package utils
import (
- "errors"
"fmt"
"github.com/apache/incubator-openwhisk-wskdeploy/wski18n"
"github.com/fatih/color"
"github.com/mattn/go-colorable"
- "os"
)
-// Check is a util function to panic when there is an error.
-func Check(e error) {
- defer func() {
- if err := recover(); err != nil {
- fmt.Printf("Runtime panic : %v", err)
- }
- }()
-
- if e != nil {
- fmt.Printf("%v", e)
- erro := errors.New("Error happened during execution, please type 'wskdeploy -h' for help messages.")
- fmt.Printf("%v", erro)
- if Flags.WithinOpenWhisk {
- PrintOpenWhiskError(e)
- } else {
- os.Exit(1)
- }
-
- }
-}
-
func PrintOpenWhiskError(err error) {
outputStream := colorable.NewColorableStderr()
fmt.Fprintf(outputStream, "%s%s", color.RedString(wski18n.T("Error: ")), err.Error())
diff --git a/utils/wskdeployerror.go b/utils/wskdeployerror.go
index 54c997e..1c7444b 100644
--- a/utils/wskdeployerror.go
+++ b/utils/wskdeployerror.go
@@ -18,249 +18,288 @@
package utils
import (
- "fmt"
- "runtime"
- "strings"
- "path/filepath"
+ "fmt"
+ "runtime"
+ "strings"
+ "path/filepath"
)
const (
- UNKNOWN = "Unknown"
- UNKNOWN_VALUE = "Unknown value"
- LINE = "line"
- PARAMETER = "Parameter"
- TYPE = "Type"
- EXPECTED = "expected"
- ACTUAL = "actual"
- YAML_FILE = "YAML file"
-
- ERROR_COMMAND_FAILED = "ERROR_COMMAND_FAILED"
- ERROR_MANIFEST_FILE_NOT_FOUND = "ERROR_MANIFEST_FILE_NOT_FOUND"
- ERROR_YAML_FILE_READ_ERROR = "ERROR_YAML_FILE_READ_ERROR"
- ERROR_YAML_FORMAT_ERROR = "ERROR_YAML_FORMAT_ERROR"
- ERROR_WHISK_CLIENT_ERROR = "ERROR_WHISK_CLIENT_ERROR"
- ERROR_WHISK_CLIENT_INVALID_CONFIG = "ERROR_WHISK_CLIENT_INVALID_CONFIG"
- ERROR_YAML_PARAMETER_TYPE_MISMATCH = "ERROR_YAML_PARAMETER_TYPE_MISMATCH"
+ LINE_UNKNOWN = "Unknown"
+ UNKNOWN_VALUE = "Unknown value"
+ FILE = "File"
+ LINE = "Line"
+ PARAMETER = "Parameter"
+ TYPE = "Type"
+ EXPECTED = "expected"
+ ACTUAL = "actual"
+ INDENT_LEVEL_1 = "==>"
+
+ ERROR_COMMAND_FAILED = "ERROR_COMMAND_FAILED"
+ ERROR_WHISK_CLIENT_ERROR = "ERROR_WHISK_CLIENT_ERROR"
+ ERROR_WHISK_CLIENT_INVALID_CONFIG = "ERROR_WHISK_CLIENT_INVALID_CONFIG"
+ ERROR_FILE_READ_ERROR = "ERROR_FILE_READ_ERROR"
+ ERROR_MANIFEST_FILE_NOT_FOUND = "ERROR_MANIFEST_FILE_NOT_FOUND"
+ ERROR_YAML_FILE_FORMAT_ERROR = "ERROR_YAML_FILE_FORMAT_ERROR"
+ ERROR_YAML_PARSER_ERROR = "ERROR_YAML_PARSER_ERROR"
+ ERROR_YAML_PARAMETER_TYPE_MISMATCH = "ERROR_YAML_PARAMETER_TYPE_MISMATCH"
+ ERROR_YAML_INVALID_PARAMETER_TYPE = "ERROR_YAML_INVALID_PARAMETER_TYPE"
)
/*
* BaseError
*/
type BaseErr struct {
- ErrorType string
- FileName string
- LineNum int
- Message string
+ ErrorType string
+ FileName string
+ LineNum int
+ Message string
}
func (e *BaseErr) Error() string {
- if e.ErrorType == "" {
- return fmt.Sprintf("%s [%d]: %s\n", e.FileName, e.LineNum, e.Message)
- }
- return fmt.Sprintf("%s [%d]: [%s]: %s\n", e.FileName, e.LineNum, e.ErrorType, e.Message)
+ return fmt.Sprintf("%s [%d]: [%s]: %s\n", e.FileName, e.LineNum, e.ErrorType, e.Message)
}
func (e *BaseErr) SetFileName(fileName string) {
- e.FileName = fileName
+ e.FileName = filepath.Base(fileName)
}
func (e *BaseErr) SetLineNum(lineNum int) {
- e.LineNum = lineNum
+ e.LineNum = lineNum
}
func (e *BaseErr) SetMessage(message string) {
- e.Message = message
+ e.Message = message
}
func (e *BaseErr) SetErrorType(errorType string) {
- e.ErrorType = errorType
+ e.ErrorType = errorType
}
// func Caller(skip int) (pc uintptr, file string, line int, ok bool)
func (e *BaseErr) SetCallerByStackFrameSkip(skip int) {
- _, fn, lineNum, _ := runtime.Caller(skip)
- e.SetFileName(filepath.Base(fn))
- e.SetLineNum(lineNum)
+ _, fname, lineNum, _ := runtime.Caller(skip)
+ e.SetFileName(fname)
+ e.SetLineNum(lineNum)
}
/*
* CommandError
*/
type CommandError struct {
- BaseErr
- Command string
+ BaseErr
+ Command string
}
func NewCommandError(cmd string, errorMessage string) *CommandError {
- var err = &CommandError{
- Command: cmd,
- }
- err.SetCallerByStackFrameSkip(2)
- err.SetErrorType(ERROR_COMMAND_FAILED)
- err.SetMessage(cmd + ": " + errorMessage)
- return err
+ var err = &CommandError{
+ Command: cmd,
+ }
+ err.SetErrorType(ERROR_COMMAND_FAILED)
+ err.SetCallerByStackFrameSkip(2)
+ err.SetMessage(cmd + ": " + errorMessage)
+ return err
}
func (e *CommandError) Error() string {
- return e.BaseErr.Error()
+ return e.BaseErr.Error()
}
/*
- * ManifestFileNotFoundError
+ * WhiskClientError
*/
-type ErrorManifestFileNotFound struct {
- BaseErr
- YAMLFilename string
+type WhiskClientError struct {
+ BaseErr
+ ErrorCode int
}
-func NewErrorManifestFileNotFound(errMessage string) *ErrorManifestFileNotFound {
- var err = &ErrorManifestFileNotFound{
- }
- err.SetErrorType(ERROR_MANIFEST_FILE_NOT_FOUND)
- err.SetCallerByStackFrameSkip(2)
- err.SetMessage(errMessage)
- return err
+func NewWhiskClientError(errorMessage string, code int) *WhiskClientError {
+ var err = &WhiskClientError{
+ ErrorCode: code,
+ }
+ err.SetErrorType(ERROR_WHISK_CLIENT_ERROR)
+ err.SetCallerByStackFrameSkip(2)
+ str := fmt.Sprintf("Error Code: %d: %s", code, errorMessage)
+ err.SetMessage(str)
+ return err
}
-func (e *ErrorManifestFileNotFound) Error() string {
- return e.BaseErr.Error()
+/*
+ * WhiskClientInvalidConfigError
+ */
+type WhiskClientInvalidConfigError struct {
+ BaseErr
+}
+
+func NewWhiskClientInvalidConfigError(errorMessage string) *WhiskClientInvalidConfigError {
+ var err = &WhiskClientInvalidConfigError{
+ }
+ err.SetErrorType(ERROR_WHISK_CLIENT_INVALID_CONFIG)
+ err.SetCallerByStackFrameSkip(2)
+ err.SetMessage(errorMessage)
+ return err
}
/*
- * YAMLFileReadError
+ * FileError
*/
-type YAMLFileReadError struct {
- BaseErr
+type FileError struct {
+ BaseErr
+ ErrorFileName string
+ ErrorFilePath string
}
-func NewYAMLFileReadError(errorMessage string) *YAMLFileReadError {
- var err = &YAMLFileReadError{
- //errorType: wski18n.T(INVALID_YAML_INPUT),
- }
- err.SetErrorType(ERROR_YAML_FILE_READ_ERROR)
- err.SetCallerByStackFrameSkip(2)
- err.SetMessage(errorMessage)
- return err
+func (e *FileError) SetErrorFilePath(fpath string) {
+ e.ErrorFilePath = fpath
+ e.ErrorFileName = filepath.Base(fpath)
}
-func (e *YAMLFileReadError) Error() string {
- return e.BaseErr.Error()
+func (e *FileError) SetErrorFileName(fname string) {
+ e.ErrorFilePath = fname
+}
+
+func (e *FileError) Error() string {
+ return fmt.Sprintf("%s [%d]: [%s]: " + FILE + ": [%s]: %s\n",
+ e.FileName,
+ e.LineNum,
+ e.ErrorType,
+ e.ErrorFileName,
+ e.Message)
}
/*
- * YAMLFormatError
+ * FileReadError
*/
-type YAMLFormatError struct {
- YAMLFileReadError
+func NewFileReadError(fpath string, errMessage string) *FileError {
+ var err = &FileError{
+ }
+ err.SetErrorType(ERROR_FILE_READ_ERROR)
+ err.SetCallerByStackFrameSkip(2)
+ err.SetErrorFilePath(fpath)
+ err.SetMessage(errMessage)
+ return err
}
-func NewYAMLFormatError(errorMessage string) *YAMLFormatError {
- var err = &YAMLFormatError{
- //err.SetErrorType(wski18n.T(INVALID_YAML_FORMAT))
- }
- err.SetErrorType(ERROR_YAML_FORMAT_ERROR)
- err.SetCallerByStackFrameSkip(2)
- err.SetMessage(errorMessage)
- return err
-}
/*
- * WhiskClientError
+ * ManifestFileNotFoundError
*/
-type WhiskClientError struct {
- BaseErr
- ErrorCode int
-}
-
-func NewWhiskClientError(errorMessage string, code int) *WhiskClientError {
- var err = &WhiskClientError{
- //errorType: wski18n.T(OPENWHISK_CLIENT_ERROR),
- ErrorCode: code,
- }
- err.SetErrorType(ERROR_WHISK_CLIENT_ERROR)
- err.SetCallerByStackFrameSkip(2)
- str := fmt.Sprintf("Error Code: %d: %s", code, errorMessage)
- err.SetMessage(str)
- return err
+type ErrorManifestFileNotFound struct {
+ FileError
}
-func (e *WhiskClientError) Error() string {
- return e.BaseErr.Error()
+func NewErrorManifestFileNotFound(fpath string, errMessage string) *ErrorManifestFileNotFound {
+ var err = &ErrorManifestFileNotFound{
+ }
+ err.SetErrorType(ERROR_MANIFEST_FILE_NOT_FOUND)
+ err.SetCallerByStackFrameSkip(2)
+ err.SetErrorFilePath(fpath)
+ err.SetMessage(errMessage)
+ return err
}
/*
- * WhiskClientInvalidConfigError
+ * YAMLFileFormatError
*/
-type WhiskClientInvalidConfigError struct {
- BaseErr
+type YAMLFileFormatError struct {
+ FileError
}
-func NewWhiskClientInvalidConfigError(errorMessage string) *WhiskClientInvalidConfigError {
- var err = &WhiskClientInvalidConfigError{
- }
- err.SetErrorType(ERROR_WHISK_CLIENT_INVALID_CONFIG)
- err.SetCallerByStackFrameSkip(2)
- err.SetMessage(errorMessage)
- return err
+func NewYAMLFileFormatError(fpath string, errorMessage string) *YAMLFileFormatError {
+ var err = &YAMLFileFormatError{
+ }
+ err.SetErrorType(ERROR_YAML_FILE_FORMAT_ERROR)
+ err.SetCallerByStackFrameSkip(2)
+ err.SetErrorFilePath(fpath)
+ err.SetMessage(errorMessage)
+ return err
}
/*
- * YAMLParserErr
+ * ParameterTypeMismatchError
*/
-type YAMLParserErr struct {
- BaseErr
- YamlFile string
- lines []string
- msgs []string
+type ParameterTypeMismatchError struct {
+ FileError
+ Parameter string
+ ExpectedType string
+ ActualType string
}
-func NewYAMLParserErr(yamlFile string, lines []string, msgs []string) *YAMLParserErr {
- var err = &YAMLParserErr{
- YamlFile: yamlFile,
- lines: lines,
- msgs: msgs,
- }
- err.SetCallerByStackFrameSkip(2)
- return err
+func NewParameterTypeMismatchError(fpath string, param string, expectedType string, actualType string) *ParameterTypeMismatchError {
+ var err = &ParameterTypeMismatchError{
+ ExpectedType: expectedType,
+ ActualType: actualType,
+ }
+
+ err.SetErrorType(ERROR_YAML_PARAMETER_TYPE_MISMATCH)
+ err.SetCallerByStackFrameSkip(2)
+ err.SetErrorFilePath(fpath)
+ str := fmt.Sprintf("%s [%s]: %s %s: [%s], %s: [%s]",
+ PARAMETER, param,
+ TYPE,
+ EXPECTED, expectedType,
+ ACTUAL, actualType)
+ err.SetMessage(str)
+ return err
}
-func (e *YAMLParserErr) Error() string {
- result := make([]string, len(e.msgs))
-
- for index, msg := range e.msgs {
- var s string
- if e.lines == nil || e.lines[index] == UNKNOWN {
- s = fmt.Sprintf("====> %s", msg)
- } else{
- s = fmt.Sprintf("====> %s [%v]: %s", LINE, e.lines[index], msg)
- }
- result[index] = s
- }
- return fmt.Sprintf("\n==> %s [%d]: %s: %s: \n%s", e.FileName, e.LineNum, YAML_FILE, e.YamlFile, strings.Join(result, "\n"))
+/*
+ * InvalidParameterType
+ */
+type InvalidParameterTypeError struct {
+ FileError
+ Parameter string
+ ActualType string
+}
+
+func NewInvalidParameterTypeError(fpath string, param string, actualType string) *ParameterTypeMismatchError {
+ var err = &ParameterTypeMismatchError{
+ ActualType: actualType,
+ }
+ err.SetErrorFilePath(fpath)
+ err.SetErrorType(ERROR_YAML_INVALID_PARAMETER_TYPE)
+ err.SetCallerByStackFrameSkip(2)
+ str := fmt.Sprintf("%s [%s]: %s [%s]",
+ PARAMETER, param,
+ TYPE, actualType)
+ err.SetMessage(str)
+ return err
}
/*
- * ParameterTypeMismatchError
+ * YAMLParserErr
*/
-type ParameterTypeMismatchError struct {
- BaseErr
- Parameter string
- ExpectedType string
- ActualType string
+type YAMLParserError struct {
+ FileError
+ lines []string
+ msgs []string
}
-func NewParameterTypeMismatchError(param string, expectedType string, actualType string) *ParameterTypeMismatchError {
- var err = &ParameterTypeMismatchError{
- ExpectedType: expectedType,
- ActualType: actualType,
- }
- err.SetErrorType(ERROR_YAML_PARAMETER_TYPE_MISMATCH)
- err.SetCallerByStackFrameSkip(2)
- str := fmt.Sprintf( "%s [%s]: %s %s: [%s], %s: [%s]", PARAMETER, param, TYPE, EXPECTED, expectedType, ACTUAL, actualType)
- err.SetMessage(str)
- return err
+func NewYAMLParserErr(fpath string, lines []string, msgs []string) *YAMLParserError {
+ var err = &YAMLParserError{
+ lines: lines,
+ msgs: msgs,
+ }
+ err.SetErrorType(ERROR_YAML_PARSER_ERROR)
+ err.SetErrorFilePath(fpath)
+ err.SetCallerByStackFrameSkip(2)
+ return err
}
-func (e *ParameterTypeMismatchError) Error() string {
- return e.BaseErr.Error()
+
+func (e *YAMLParserError) Error() string {
+ result := make([]string, len(e.msgs))
+
+ for index, msg := range e.msgs {
+ var s string
+ if e.lines == nil || e.lines[index] == LINE_UNKNOWN {
+ s = fmt.Sprintf("\n%s %s [%v]: %s", INDENT_LEVEL_1, LINE, LINE_UNKNOWN, msg)
+ } else {
+ s = fmt.Sprintf("\n%s %s [%v]: %s", INDENT_LEVEL_1, LINE, e.lines[index], msg)
+ }
+ result[index] = s
+ }
+
+ e.SetMessage(strings.Join(result, ""))
+ return e.FileError.Error()
}
diff --git a/utils/wskdeployerror_test.go b/utils/wskdeployerror_test.go
new file mode 100644
index 0000000..18c809e
--- /dev/null
+++ b/utils/wskdeployerror_test.go
@@ -0,0 +1,184 @@
+// +build unit
+
+/*
+ * 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 utils
+
+import (
+ "testing"
+ "github.com/stretchr/testify/assert"
+ "strings"
+ "fmt"
+ "runtime"
+ "path/filepath"
+)
+
+/*
+ * TestCustomErrorOutputFormat
+ */
+func TestCustomErrorOutputFormat(t *testing.T) {
+
+ _, fn, _, _ := runtime.Caller(0)
+ packageName := filepath.Base(fn)
+ const TEST_DEFAULT_ERROR_MESSAGE = "Some bad error"
+ const TEST_COMMAND string = "test"
+ const TEST_ERROR_CODE = 400 // Bad request
+ const TEST_EXISTANT_MANIFEST_FILE = "tests/dat/manifest_validate_multiline_params.yaml"
+ const TEST_NONEXISTANT_MANIFEST_FILE = "tests/dat/missing_manifest.yaml"
+ const TEST_INVALID_YAML_MANIFEST_FILE = "tests/dat/manifest_bad_yaml_invalid_comment.yaml"
+ const TEST_PARAM_NAME = "Age"
+ const TEST_PARAM_TYPE_INT = "integer"
+ const TEST_PARAM_TYPE_FLOAT = "float"
+ const TEST_PARAM_TYPE_FOO = "foo"
+
+ /*
+ * CommandError
+ */
+ err1 := NewCommandError(TEST_COMMAND, TEST_DEFAULT_ERROR_MESSAGE)
+ actualResult := strings.TrimSpace(err1.Error())
+ expectedResult := fmt.Sprintf("%s [%d]: [%s]: %s: %s",
+ packageName,
+ err1.LineNum,
+ ERROR_COMMAND_FAILED,
+ TEST_COMMAND,
+ TEST_DEFAULT_ERROR_MESSAGE )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * WhiskClientError
+ */
+ err2 := NewWhiskClientError(TEST_DEFAULT_ERROR_MESSAGE, TEST_ERROR_CODE)
+ actualResult = strings.TrimSpace(err2.Error())
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: Error Code: %d: %s",
+ packageName,
+ err2.LineNum,
+ ERROR_WHISK_CLIENT_ERROR,
+ TEST_ERROR_CODE,
+ TEST_DEFAULT_ERROR_MESSAGE )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * WhiskClientInvalidConfigError
+ */
+ err3 := NewWhiskClientInvalidConfigError(TEST_DEFAULT_ERROR_MESSAGE)
+ actualResult = strings.TrimSpace(err3.Error())
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: %s",
+ packageName,
+ err3.LineNum,
+ ERROR_WHISK_CLIENT_INVALID_CONFIG,
+ TEST_DEFAULT_ERROR_MESSAGE )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * FileReadError
+ */
+ err4 := NewFileReadError(TEST_NONEXISTANT_MANIFEST_FILE, TEST_DEFAULT_ERROR_MESSAGE)
+ actualResult = strings.TrimSpace(err4.Error())
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: " + FILE + ": [%s]: %s",
+ packageName,
+ err4.LineNum,
+ ERROR_FILE_READ_ERROR,
+ filepath.Base(TEST_NONEXISTANT_MANIFEST_FILE),
+ TEST_DEFAULT_ERROR_MESSAGE )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * ManifestFileNotFoundError
+ */
+ err5 := NewErrorManifestFileNotFound(TEST_NONEXISTANT_MANIFEST_FILE, TEST_DEFAULT_ERROR_MESSAGE)
+ actualResult = strings.TrimSpace(err5.Error())
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: " + FILE + ": [%s]: %s",
+ packageName,
+ err5.LineNum,
+ ERROR_MANIFEST_FILE_NOT_FOUND,
+ filepath.Base(TEST_NONEXISTANT_MANIFEST_FILE),
+ TEST_DEFAULT_ERROR_MESSAGE )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * YAMLFileFormatError
+ */
+ err6 := NewYAMLFileFormatError(TEST_INVALID_YAML_MANIFEST_FILE, TEST_DEFAULT_ERROR_MESSAGE)
+ actualResult = strings.TrimSpace(err6.Error())
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: " + FILE + ": [%s]: %s",
+ packageName,
+ err6.LineNum,
+ ERROR_YAML_FILE_FORMAT_ERROR,
+ filepath.Base(TEST_INVALID_YAML_MANIFEST_FILE),
+ TEST_DEFAULT_ERROR_MESSAGE )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * ParameterTypeMismatchError
+ */
+ err8 := NewParameterTypeMismatchError(
+ TEST_EXISTANT_MANIFEST_FILE,
+ TEST_PARAM_NAME,
+ TEST_PARAM_TYPE_INT,
+ TEST_PARAM_TYPE_FLOAT)
+ actualResult = strings.TrimSpace(err8.Error())
+ msg8 := fmt.Sprintf("%s [%s]: %s %s: [%s], %s: [%s]",
+ PARAMETER, TEST_PARAM_NAME,
+ TYPE,
+ EXPECTED, TEST_PARAM_TYPE_INT,
+ ACTUAL, TEST_PARAM_TYPE_FLOAT)
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: " + FILE + ": [%s]: %s",
+ packageName,
+ err8.LineNum,
+ ERROR_YAML_PARAMETER_TYPE_MISMATCH,
+ filepath.Base(TEST_EXISTANT_MANIFEST_FILE),
+ msg8 )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * InvalidParameterType
+ */
+ err9 := NewInvalidParameterTypeError(TEST_EXISTANT_MANIFEST_FILE, TEST_PARAM_NAME, TEST_PARAM_TYPE_FOO)
+ actualResult = strings.TrimSpace(err9.Error())
+ msg9 := fmt.Sprintf("%s [%s]: %s [%s]",
+ PARAMETER, TEST_PARAM_NAME,
+ TYPE, TEST_PARAM_TYPE_FOO)
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: " + FILE + ": [%s]: %s",
+ packageName,
+ err9.LineNum,
+ ERROR_YAML_INVALID_PARAMETER_TYPE,
+ filepath.Base(TEST_EXISTANT_MANIFEST_FILE),
+ msg9 )
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+
+ /*
+ * YAMLParserErr
+ */
+ var TEST_LINES = []string{"40", LINE_UNKNOWN, "123"}
+ var TEST_MESSAGES = []string{"did not find expected key", "did not find expected ',' or ']'", "found duplicate %YAML directive"}
+
+ err10 := NewYAMLParserErr(TEST_EXISTANT_MANIFEST_FILE, TEST_LINES, TEST_MESSAGES)
+ actualResult = strings.TrimSpace(err10.Error())
+
+ msgs := "\n==> Line [40]: did not find expected key" +
+ "\n==> Line [Unknown]: did not find expected ',' or ']'" +
+ "\n==> Line [123]: found duplicate %YAML directive"
+
+ expectedResult = fmt.Sprintf("%s [%d]: [%s]: " + FILE + ": [%s]: %s",
+ packageName,
+ err10.LineNum,
+ ERROR_YAML_PARSER_ERROR,
+ filepath.Base(TEST_EXISTANT_MANIFEST_FILE),
+ msgs)
+ assert.Equal(t, expectedResult, actualResult, "Expected [" + expectedResult + "] but got [" + actualResult + "]")
+}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services