openwhisk-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mrutkow...@apache.org
Subject [incubator-openwhisk-client-go] branch master updated: Load the credentials for the client go library (#29)
Date Fri, 25 Aug 2017 02:33:26 GMT
This is an automated email from the ASF dual-hosted git repository.

mrutkowski pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-openwhisk-client-go.git


The following commit(s) were added to refs/heads/master by this push:
     new 9967197  Load the credentials for the client go library (#29)
9967197 is described below

commit 9967197c380473452597d8f49c3ddb607933e6ae
Author: Vincent <shou@us.ibm.com>
AuthorDate: Thu Aug 24 22:33:24 2017 -0400

    Load the credentials for the client go library (#29)
    
    There are two ways to configure the credentials for client go, which are local wskprops, and
    whisk.properties from openwhisk in a precedence descending order.
    
    For local wskprops: we can specify the path of the local properties file or it will
    by default look up the file under system HOME dir. The valid file name is .wskprops.
    
    For openwhisk properties file, we will look up the OPENWHISK_HOME directory to load whisk.properties
    in order to get the credentials to access openwhisk service.
    
    Closes-Bug: #22
---
 .travis.yml                      |   6 +-
 Godeps/Godeps.json               |   2 +-
 Makefile                         |  16 +
 tools/travis/test_openwhisk.sh   |   3 +
 whisk/client.go                  |  14 +-
 whisk/wskprops.go                | 354 +++++++++++++++
 whisk/wskprops_test.go           | 902 +++++++++++++++++++++++++++++++++++++++
 wski18n/i18n_resources.go        |  28 +-
 wski18n/resources/en_US.all.json |  24 ++
 9 files changed, 1328 insertions(+), 21 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index c57dd18..a6085a6 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,7 +6,7 @@ matrix:
     include:
         - os: linux
           sudo: required
-          go: 1.7
+          go: 1.8
           services: docker
 
 git:
@@ -20,11 +20,11 @@ install:
   - export DEPLOY_BUILD_READY=false
   - go get -u github.com/golang/lint/golint
   - go get -u github.com/stretchr/testify
-  - go get -u github.com/spf13/viper
 
 script:
   - ./tools/travis/build.sh
   - export PATH=$PATH:$TRAVIS_BUILD_DIR;
+  - make test
   - if [ "$TRAVIS_OS_NAME" == "linux" ] ; then
       ./tools/travis/test_openwhisk.sh;
-    fi
\ No newline at end of file
+    fi
diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index 2b1ffba..7ce5a87 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,5 +1,5 @@
 {
 	"ImportPath": "github.com/apache/incubator-openwhisk-client-go",
-	"GoVersion": "go1.7",
+	"GoVersion": "go1.8",
 	"Deps": []
 }
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..2a3afee
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,16 @@
+deps:
+	@echo "Installing dependencies"
+	go get -d -t ./...
+
+updatedeps:
+	@echo "Updating all dependencies"
+	@go get -d -u -f -fix -t ./...
+
+test: deps
+	@echo "Testing"
+	go test -v ./... -tags=unit
+
+# Run the integration test against OpenWhisk
+integration_test:
+	@echo "Launch the integration tests."
+	go test -v ./... -tags=integration
diff --git a/tools/travis/test_openwhisk.sh b/tools/travis/test_openwhisk.sh
index 3a660df..10d498b 100755
--- a/tools/travis/test_openwhisk.sh
+++ b/tools/travis/test_openwhisk.sh
@@ -25,3 +25,6 @@ $ANSIBLE_CMD initdb.yml
 $ANSIBLE_CMD apigateway.yml
 $ANSIBLE_CMD wipe.yml
 $ANSIBLE_CMD openwhisk.yml -e '{"openwhisk_cli":{"installation_mode":"remote","remote":{"name":"OpenWhisk_CLI","dest_name":"OpenWhisk_CLI","location":"https://github.com/apache/incubator-openwhisk-cli/releases/download/latest"}}}'
+
+cd $TRAVIS_BUILD_DIR
+make integration_test
diff --git a/whisk/client.go b/whisk/client.go
index 9ea5823..8b9339f 100644
--- a/whisk/client.go
+++ b/whisk/client.go
@@ -78,7 +78,19 @@ type Config struct {
     Insecure    bool
 }
 
-func NewClient(httpClient *http.Client, config *Config) (*Client, error) {
+func NewClient(httpClient *http.Client, config_input *Config) (*Client, error) {
+
+    var config *Config
+    if config_input == nil {
+        defaultConfig, err := GetDefaultConfig()
+        if err != nil {
+            return nil ,err
+        } else {
+            config = defaultConfig
+        }
+    } else {
+        config = config_input
+    }
 
     // Disable certificate checking in the dev environment if in insecure mode
     if config.Insecure {
diff --git a/whisk/wskprops.go b/whisk/wskprops.go
new file mode 100644
index 0000000..57f6644
--- /dev/null
+++ b/whisk/wskprops.go
@@ -0,0 +1,354 @@
+/*
+ * 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 whisk
+
+import (
+    "io/ioutil"
+    "fmt"
+    "net/url"
+    "os"
+    "strings"
+    "bufio"
+    "errors"
+    "github.com/apache/incubator-openwhisk-client-go/wski18n"
+)
+
+const (
+    OPENWHISK_HOME = "OPENWHISK_HOME"
+    GOPATH = "GOPATH"
+    DEFAULT_LOCAL_CONFIG = ".wskprops"
+    OPENWHISK_PROPERTIES = "whisk.properties"
+    TEST_AUTH_FILE = "testing.auth"
+    OPENWHISK_PRO= "whisk.api.host.proto"
+    OPENWHISK_PORT= "whisk.api.host.port"
+    OPENWHISK_HOST= "whisk.api.host.name"
+    DEFAULT_VERSION = "v1"
+    DEFAULT_NAMESPACE = "guest"
+    DEFAULT_API = "api"
+
+    NAMESPACE = "NAMESPACE"
+    AUTH = "AUTH"
+    WHISK_APIHOST = "WHISK_APIHOST"
+    APIGW_ACCESS_TOKEN = "APIGW_ACCESS_TOKEN"
+    APIVERSION = "APIVERSION"
+    KEY = "KEY"
+    CERT = "CERT"
+    APIHOST = "APIHOST"
+
+    DEFAULT_SOURCE = ".wskprops"
+    WSKPROP = ".wskprops"
+    WHISK_PROPERTY = "whisk.properties"
+)
+
+type Wskprops struct {
+    WHISKAPIURL string
+    APIHost string
+    AuthKey string
+    Namespace string
+    AuthAPIGWKey string
+    APIGWSpaceSuid string
+    Apiversion string
+    Key string
+    Cert string
+    Source string
+}
+
+func convertWskpropsToConfig(dep *Wskprops) *Config {
+    var config Config
+    var err error
+    config.BaseURL, err = url.Parse(dep.WHISKAPIURL)
+    if err != nil {
+        config.BaseURL = nil
+    }
+    config.Namespace = dep.Namespace
+    config.Cert = dep.Cert
+    config.Key = dep.Key
+    config.AuthToken = dep.AuthKey
+
+    if config.BaseURL != nil {
+        config.Host = config.BaseURL.Host
+    } else {
+        config.Host = ""
+    }
+
+    config.Version = dep.Apiversion
+    config.Verbose = false
+    config.Debug = false
+    config.Insecure = true
+
+    return &config
+}
+
+func GetDefaultConfigFromProperties(pi Properties) (*Config, error) {
+    var config *Config
+    dep, e := GetDefaultWskProp(pi)
+    if (e != nil) {
+        return config, e
+    }
+    config = convertWskpropsToConfig(dep)
+    return config, e
+}
+
+func GetConfigFromWhiskProperties(pi Properties) (*Config, error) {
+    var config *Config
+    dep, e := GetWskPropFromWhiskProperty(pi)
+    if (e != nil) {
+        return config, e
+    }
+    config = convertWskpropsToConfig(dep)
+    return config, e
+}
+
+func GetConfigFromWskprops(pi Properties, path string) (*Config, error) {
+    var config *Config
+    dep, e := GetWskPropFromWskprops(pi, path)
+    if (e != nil) {
+        return config, e
+    }
+    config = convertWskpropsToConfig(dep)
+    return config, e
+}
+
+var GetDefaultWskProp = func (pi Properties) (*Wskprops, error) {
+    var dep *Wskprops
+    dep = pi.GetPropsFromWskprops("")
+    error := ValidateWskprops(dep)
+    if error != nil {
+        dep_whisk := pi.GetPropsFromWhiskProperties()
+        error_whisk := ValidateWskprops(dep_whisk)
+        if error_whisk != nil {
+            return dep, error
+        } else {
+            return dep_whisk, error_whisk
+        }
+    }
+    return dep, error
+}
+
+var GetWskPropFromWskprops = func (pi Properties, path string) (*Wskprops, error) {
+    var dep *Wskprops
+    dep = pi.GetPropsFromWskprops(path)
+    error := ValidateWskprops(dep)
+    return dep, error
+}
+
+var GetWskPropFromWhiskProperty = func (pi Properties) (*Wskprops, error) {
+    var dep *Wskprops
+    dep = pi.GetPropsFromWhiskProperties()
+    error := ValidateWskprops(dep)
+    return dep, error
+}
+
+type Properties interface {
+    GetPropsFromWskprops(string) *Wskprops
+    GetPropsFromWhiskProperties() *Wskprops
+}
+
+type PropertiesImp struct {
+    osPackage OSPackage
+}
+
+func (pi PropertiesImp) GetPropsFromWskprops(path string) *Wskprops {
+    dep := GetDefaultWskprops(WSKPROP)
+
+    var configPath string
+    if path != "" {
+        configPath = path
+    } else {
+        configPath = pi.osPackage.Getenv(GOPATH, "")
+    }
+    results, err := ReadProps(configPath + "/" + DEFAULT_LOCAL_CONFIG)
+
+    if err == nil {
+
+        dep.WHISKAPIURL = GetValue(results, WHISK_APIHOST, dep.WHISKAPIURL)
+        baseURL, err := url.Parse(dep.WHISKAPIURL)
+        if err != nil {
+            dep.APIHost = GetValue(results, APIHOST, dep.APIHost)
+        } else {
+            dep.APIHost = baseURL.Host
+        }
+        dep.AuthKey = GetValue(results, AUTH, dep.AuthKey)
+        dep.Namespace = GetValue(results, NAMESPACE, dep.Namespace)
+        dep.AuthAPIGWKey = GetValue(results, APIGW_ACCESS_TOKEN, dep.AuthAPIGWKey)
+        if len(dep.AuthKey) > 0 {
+            dep.APIGWSpaceSuid = strings.Split(dep.AuthKey, ":")[0]
+        }
+        dep.Apiversion = GetValue(results, APIVERSION, dep.Apiversion)
+        dep.Key = GetValue(results, KEY, dep.Key)
+        dep.Cert = GetValue(results, CERT, dep.Cert)
+    }
+
+    return dep
+}
+
+func (pi PropertiesImp) GetPropsFromWhiskProperties() *Wskprops {
+    dep := GetDefaultWskprops(WHISK_PROPERTY)
+    path := pi.osPackage.Getenv(OPENWHISK_HOME, "") + "/" + OPENWHISK_PROPERTIES
+    results, err := ReadProps(path)
+
+    if err == nil {
+        authPath := GetValue(results, TEST_AUTH_FILE, "")
+        b, err := ioutil.ReadFile(authPath)
+        if err == nil {
+            dep.AuthKey = strings.TrimSpace(string(b))
+        }
+
+        var pro = GetValue(results, OPENWHISK_PRO, "")
+        var port = GetValue(results, OPENWHISK_PORT, "")
+        var host = GetValue(results, OPENWHISK_HOST, "")
+        dep.WHISKAPIURL = fmt.Sprintf("%s://%s:%s/%s", pro, host, port, DEFAULT_API)
+        baseURL, err := url.Parse(dep.WHISKAPIURL)
+        if err != nil {
+            dep.APIHost = fmt.Sprintf("%s:%s", host, port)
+        } else {
+            dep.APIHost = baseURL.Host
+        }
+        dep.Namespace = DEFAULT_NAMESPACE
+        if len(dep.AuthKey) > 0 {
+            dep.APIGWSpaceSuid = strings.Split(dep.AuthKey, ":")[0]
+        }
+    }
+    return dep
+}
+
+var ValidateWskprops = func (wskprops *Wskprops) error {
+    // There are at least two fields: WHISKAPIURL and AuthKey, mandatory for a valid Wskprops.
+    errStr := ""
+    if (len(wskprops.WHISKAPIURL) == 0) {
+        if wskprops.Source == WHISK_PROPERTY {
+            errStr = wski18n.T("OpenWhisk API URL is missing (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)")
+        } else {
+            errStr = wski18n.T("OpenWhisk API URL is missing (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)")
+        }
+        return MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
+    } else {
+        _, err := url.ParseRequestURI(wskprops.WHISKAPIURL)
+        if (err != nil) {
+            if wskprops.Source == WHISK_PROPERTY {
+                errStr = wski18n.T("Invalid OpenWhisk API URL (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)")
+            } else {
+                errStr = wski18n.T("Invalid OpenWhisk API URL (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)")
+            }
+            return MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
+        } else if (len(wskprops.AuthKey) == 0) {
+            if wskprops.Source == WHISK_PROPERTY {
+                errStr = wski18n.T("Authentication key is missing (Please configure AUTH in .wskprops under the system HOME directory.)")
+            } else {
+                errStr = wski18n.T("Authentication key is missing (Please configure testing.auth as the path of the authentication key file in whisk.properties under the OPENWHISK_HOME directory.)")
+            }
+            return MakeWskError(errors.New(errStr), EXIT_CODE_ERR_GENERAL, DISPLAY_MSG, DISPLAY_USAGE)
+        } else {
+            return nil
+        }
+    }
+}
+
+type OSPackage interface {
+    Getenv(key string, defaultValue string) string
+}
+
+type OSPackageImp struct {}
+
+func (osPackage OSPackageImp) Getenv(key string, defaultValue string) string {
+    value := os.Getenv(key)
+    if len(value) == 0 {
+        return defaultValue
+    }
+    return value
+}
+
+func GetDefaultConfig() (*Config, error) {
+    pi := PropertiesImp{
+        osPackage: OSPackageImp{},
+    }
+    return GetDefaultConfigFromProperties(pi)
+}
+
+func GetWhiskPropertiesConfig() (*Config, error) {
+    pi := PropertiesImp{
+        osPackage: OSPackageImp{},
+    }
+    return GetConfigFromWhiskProperties(pi)
+}
+
+func GetWskpropsConfig(path string) (*Config, error) {
+    pi := PropertiesImp{
+        osPackage: OSPackageImp{},
+    }
+    return GetConfigFromWskprops(pi, path)
+}
+
+func GetDefaultWskprops(source string) *Wskprops {
+    if len(source) == 0 {
+        source = DEFAULT_SOURCE
+    }
+
+    dep := Wskprops {
+        WHISKAPIURL: "",
+        APIHost: "",
+        AuthKey: "",
+        Namespace: DEFAULT_NAMESPACE,
+        AuthAPIGWKey: "",
+        APIGWSpaceSuid: "",
+        Apiversion: DEFAULT_VERSION,
+        Key: "",
+        Cert: "",
+        Source: source,
+    }
+    return &dep
+}
+
+func GetValue(StoredValues map[string]string, key string, defaultvalue string) string {
+    if val, ok := StoredValues[key]; ok {
+        return val
+    } else {
+        return defaultvalue
+    }
+}
+
+func ReadProps(path string) (map[string]string, error) {
+
+    props := map[string]string{}
+
+    file, err := os.Open(path)
+    if err != nil {
+        return props, err
+    }
+    defer file.Close()
+
+    lines := []string{}
+    scanner := bufio.NewScanner(file)
+    for scanner.Scan() {
+        lines = append(lines, scanner.Text())
+    }
+
+    props = map[string]string{}
+    for _, line := range lines {
+        kv := strings.Split(line, "=")
+        if len(kv) != 2 {
+            continue
+        }
+        key := strings.TrimSpace(kv[0])
+        value := strings.TrimSpace(kv[1])
+        props[key] = value
+    }
+
+    return props, nil
+
+}
diff --git a/whisk/wskprops_test.go b/whisk/wskprops_test.go
new file mode 100644
index 0000000..4becded
--- /dev/null
+++ b/whisk/wskprops_test.go
@@ -0,0 +1,902 @@
+// +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 whisk
+
+import (
+    "testing"
+    "github.com/stretchr/testify/assert"
+    "os"
+    "fmt"
+    "bufio"
+)
+
+const (
+    TEST_FILE = "TEST_AUTH_FILE"
+    NON_EXISTING_TEST_FILE = "NON_EXISTING_TEST_FILE"
+    EXPECTED_OPENWHISK_HOST = "192.168.9.100"
+    EXPECTED_OPENWHISK_PORT = "443"
+    EXPECTED_OPENWHISK_PRO = "https"
+    EXPECTED_TEST_AUTH_KEY = EXPECTED_API_GW_SPACE_SUID + ":123zO3xZCLrMN6v2BKK1dXYFpXlPkccOFqm12CdAsMgRU4VrNZ9lyGVCGuMDGouh"
+    EXPECTED_API_HOST= EXPECTED_OPENWHISK_PRO + "://" + EXPECTED_OPENWHISK_HOST + ":" + EXPECTED_OPENWHISK_PORT + "/api"
+    EXPECTED_HOST= EXPECTED_OPENWHISK_HOST + ":" + EXPECTED_OPENWHISK_PORT
+    EXPECTED_AUTH_API_KEY = "EXPECTED_AUTH_API_KEY"
+    EXPECTED_API_GW_SPACE_SUID = "32kc46b1-71f6-4ed5-8c54-816aa4f8c502"
+    APIGW_SPACE_SUID = "APIGW_SPACE_SUID"
+    EXPECTED_API_VERSION = "v1"
+    EXPECTED_CERT = "EXPECTED_CERT"
+    EXPECTED_KEY = "EXPECTED_KEY"
+
+    EXPECTED_API_URL_WHISK = "http://localhost/apihost"
+    EXPECTED_API_HOST_WHISK = "localhost"
+    EXPECTED_TEST_AUTH_KEY_WHISK = "EXPECTED_TEST_AUTH_KEY_WHISK"
+    EXPECTED_NAMESPACE_WHISK = "EXPECTED_NAMESPACE_WHISK"
+    EXPECTED_AUTH_API_KEY_WHISK = "EXPECTED_AUTH_API_KEY_WHISK"
+    EXPECTED_API_GW_SPACE_SUID_WHISK = "EXPECTED_API_GW_SPACE_SUID_WHISK"
+    EXPECTED_API_VERSION_WHISK = "EXPECTED_API_VERSION_WHISK"
+    EXPECTED_CERT_WHISK = "EXPECTED_CERT_WHISK"
+    EXPECTED_KEY_WHISK = "EXPECTED_KEY_WHISK"
+
+    EXPECTED_API_URL_LOCAL_CONF = "http://localhost:90/apilocalhost"
+    EXPECTED_API_HOST_LOCAL_CONF = "localhost:90"
+    EXPECTED_TEST_AUTH_KEY_LOCAL_CONF = "EXPECTED_TEST_AUTH_KEY_LOCAL_CONF"
+    EXPECTED_NAMESPACE_LOCAL_CONF = "EXPECTED_NAMESPACE_LOCAL_CONF"
+    EXPECTED_AUTH_API_KEY_LOCAL_CONF = "EXPECTED_AUTH_API_KEY_LOCAL_CONF"
+    EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF = "EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF"
+    EXPECTED_API_VERSION_LOCAL_CONF = "EXPECTED_API_VERSION_LOCAL_CONF"
+    EXPECTED_CERT_LOCAL_CONF = "EXPECTED_CERT_LOCAL_CONF"
+    EXPECTED_KEY_LOCAL_CONF = "EXPECTED_KEY_LOCAL_CONF"
+
+    MISSING_AUTH = "Authentication key is missing"
+    MISSING_URL = "OpenWhisk API URL is missing"
+    INVALID_URL = "Invalid OpenWhisk API URL"
+)
+
+type FakeOSPackage struct {
+    StoredValues map[string]string
+}
+
+func (osPackage FakeOSPackage) Getenv(key string, defaultValue string) string {
+    if val, ok := osPackage.StoredValues[key]; ok {
+        return val
+    } else {
+        return defaultValue
+    }
+}
+
+type FakeViperImp struct {
+    StoredValues map[string]string
+    ReadInErr error
+}
+
+func (viperImp FakeViperImp) GetString(key string, defaultvalue string) string {
+    if val, ok := viperImp.StoredValues[key]; ok {
+        return val
+    } else {
+        return defaultvalue
+    }
+}
+
+func (viperImp FakeViperImp) ReadInConfig() error {
+    return viperImp.ReadInErr
+}
+
+func (viperImp FakeViperImp) SetConfigName(in string) {
+}
+
+func (viperImp FakeViperImp) AddConfigPath(in string) {
+}
+
+func getCurrentDir() string {
+    dir, err := os.Getwd()
+    if err != nil {
+        return os.Getenv("GOPATH") + "/src/github.com/apache/incubator-openwhisk-client-go/whisk"
+    }
+    return dir
+}
+
+type FakePropertiesImp struct {
+    StoredValues_LOCAL_CONF map[string]string
+    StoredValues_WHISK map[string]string
+}
+
+func (pi FakePropertiesImp) GetPropsFromWskprops(path string) *Wskprops {
+    dep := Wskprops {
+        WHISKAPIURL: GetValue(pi.StoredValues_LOCAL_CONF, WHISK_APIHOST, ""),
+        APIHost: GetValue(pi.StoredValues_LOCAL_CONF, APIHOST, ""),
+        AuthKey: GetValue(pi.StoredValues_LOCAL_CONF, AUTH, ""),
+        Namespace: GetValue(pi.StoredValues_LOCAL_CONF, NAMESPACE, ""),
+        AuthAPIGWKey: GetValue(pi.StoredValues_LOCAL_CONF, APIGW_ACCESS_TOKEN, ""),
+        APIGWSpaceSuid: GetValue(pi.StoredValues_LOCAL_CONF, APIGW_SPACE_SUID, ""),
+        Cert: GetValue(pi.StoredValues_LOCAL_CONF, CERT, ""),
+        Key: GetValue(pi.StoredValues_LOCAL_CONF, KEY, ""),
+        Apiversion: GetValue(pi.StoredValues_LOCAL_CONF, APIVERSION, ""),
+    }
+
+    return &dep
+}
+
+func (pi FakePropertiesImp) GetPropsFromWhiskProperties() *Wskprops {
+    dep := Wskprops {
+        WHISKAPIURL: pi.StoredValues_WHISK[WHISK_APIHOST],
+        APIHost: pi.StoredValues_WHISK[APIHOST],
+        AuthKey: pi.StoredValues_WHISK[AUTH],
+        Namespace: pi.StoredValues_WHISK[NAMESPACE],
+        AuthAPIGWKey: pi.StoredValues_WHISK[APIGW_ACCESS_TOKEN],
+        APIGWSpaceSuid: pi.StoredValues_WHISK[APIGW_SPACE_SUID],
+        Cert: pi.StoredValues_WHISK[CERT],
+        Key: pi.StoredValues_WHISK[KEY],
+        Apiversion: pi.StoredValues_WHISK[APIVERSION],
+    }
+    return &dep
+}
+
+func CreateFile(lines []string, path string) error {
+    file, err := os.Create(path)
+    if err != nil {
+        return err
+    }
+    defer file.Close()
+
+    w := bufio.NewWriter(file)
+    for _, line := range lines {
+        fmt.Fprintln(w, line)
+    }
+    return w.Flush()
+}
+
+func DeleteFile(path string) error {
+    return os.Remove(path)
+}
+
+func TestGetPropsFromWhiskProperties(t *testing.T) {
+    lines := []string{ EXPECTED_TEST_AUTH_KEY }
+    CreateFile(lines, TEST_FILE)
+
+    fakeOSPackage := FakeOSPackage {
+        StoredValues: map[string]string {
+            OPENWHISK_HOME: getCurrentDir(),
+        },
+    }
+    pi := PropertiesImp{
+        osPackage: fakeOSPackage,
+    }
+    dep := pi.GetPropsFromWhiskProperties()
+    assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+    assert.Equal(t, "", dep.AuthKey)
+    assert.Equal(t, "", dep.AuthAPIGWKey)
+    assert.Equal(t, "", dep.APIHost)
+    assert.Equal(t, "", dep.APIGWSpaceSuid)
+    assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
+    assert.Equal(t, "", dep.Key)
+    assert.Equal(t, "", dep.Cert)
+    assert.Equal(t, "", dep.WHISKAPIURL)
+    assert.Equal(t, WHISK_PROPERTY, dep.Source)
+
+    lines = []string{ TEST_AUTH_FILE + "=" + TEST_FILE, OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
+        OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
+        OPENWHISK_HOST + "=" +  EXPECTED_OPENWHISK_HOST,
+    }
+
+
+    CreateFile(lines, OPENWHISK_PROPERTIES)
+    pi = PropertiesImp{
+        osPackage: fakeOSPackage,
+    }
+    dep = pi.GetPropsFromWhiskProperties()
+    assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
+    assert.Equal(t, "", dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_HOST, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_HOST, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
+    assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
+    assert.Equal(t, "", dep.Key)
+    assert.Equal(t, "", dep.Cert)
+    assert.Equal(t, WHISK_PROPERTY, dep.Source)
+
+    DeleteFile(OPENWHISK_PROPERTIES)
+
+    DeleteFile(NON_EXISTING_TEST_FILE)
+    lines = []string{ TEST_AUTH_FILE + "=" + NON_EXISTING_TEST_FILE, OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
+        OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
+        OPENWHISK_HOST + "=" +  EXPECTED_OPENWHISK_HOST}
+    CreateFile(lines, OPENWHISK_PROPERTIES)
+    pi = PropertiesImp{
+        osPackage: fakeOSPackage,
+    }
+    dep = pi.GetPropsFromWhiskProperties()
+    assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+    assert.Equal(t, "", dep.AuthKey)
+    assert.Equal(t, "", dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_HOST, dep.APIHost)
+    assert.Equal(t, "", dep.APIGWSpaceSuid)
+    assert.Equal(t, DEFAULT_VERSION, dep.Apiversion)
+    assert.Equal(t, "", dep.Key)
+    assert.Equal(t, "", dep.Cert)
+    assert.Equal(t, WHISK_PROPERTY, dep.Source)
+    DeleteFile(OPENWHISK_PROPERTIES)
+
+    DeleteFile(TEST_FILE)
+}
+
+func TestGetPropsFromWskprops(t *testing.T) {
+    lines := []string{ WHISK_APIHOST + "=" + EXPECTED_API_HOST, AUTH + "=" + EXPECTED_TEST_AUTH_KEY,
+        NAMESPACE + "=" + DEFAULT_NAMESPACE,
+        APIGW_ACCESS_TOKEN + "=" + EXPECTED_AUTH_API_KEY, APIVERSION + "=" + EXPECTED_API_VERSION,
+        KEY + "=" + EXPECTED_KEY, CERT + "=" + EXPECTED_CERT}
+    CreateFile(lines, DEFAULT_LOCAL_CONFIG)
+
+    fakeOSPackage := FakeOSPackage{
+        StoredValues: map[string]string {
+            GOPATH: getCurrentDir(),
+        },
+    }
+    pi := PropertiesImp{
+        osPackage: fakeOSPackage,
+    }
+
+    dep := pi.GetPropsFromWskprops("")
+    assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_HOST, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_HOST, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_VERSION, dep.Apiversion)
+    assert.Equal(t, EXPECTED_KEY, dep.Key)
+    assert.Equal(t, EXPECTED_CERT, dep.Cert)
+    assert.Equal(t, WSKPROP, dep.Source)
+
+    path := getCurrentDir()
+    dep = pi.GetPropsFromWskprops(path)
+    assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_HOST, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_HOST, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_VERSION, dep.Apiversion)
+    assert.Equal(t, EXPECTED_KEY, dep.Key)
+    assert.Equal(t, EXPECTED_CERT, dep.Cert)
+    assert.Equal(t, WSKPROP, dep.Source)
+
+    DeleteFile(DEFAULT_LOCAL_CONFIG)
+}
+
+func TestGetDefaultConfigFromProperties(t *testing.T) {
+    fakeProperties := FakePropertiesImp{
+        StoredValues_LOCAL_CONF: map[string]string {
+            WHISK_APIHOST: EXPECTED_API_HOST,
+            APIHOST: EXPECTED_HOST,
+            AUTH: EXPECTED_AUTH_API_KEY,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err := GetDefaultConfigFromProperties(fakeProperties)
+    assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+    assert.Equal(t, EXPECTED_CERT, config.Cert)
+    assert.Equal(t, EXPECTED_KEY, config.Key)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
+    assert.Equal(t, EXPECTED_HOST, config.Host)
+    assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
+    assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+    assert.False(t, config.Verbose)
+    assert.False(t, config.Debug)
+    assert.True(t, config.Insecure)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: map[string]string {
+            APIHOST: EXPECTED_HOST,
+            AUTH: EXPECTED_AUTH_API_KEY,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err = GetDefaultConfigFromProperties(fakeProperties)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), "OpenWhisk API URL is missing")
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: map[string]string {
+            WHISK_APIHOST: "invalid_url",
+            APIHOST: EXPECTED_HOST,
+            AUTH: EXPECTED_AUTH_API_KEY,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err = GetDefaultConfigFromProperties(fakeProperties)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), "Invalid OpenWhisk API URL")
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: map[string]string {
+            WHISK_APIHOST: EXPECTED_API_HOST,
+            APIHOST: EXPECTED_HOST,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err = GetDefaultConfigFromProperties(fakeProperties)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), "Authentication key is missing")
+}
+
+func TestGetConfigFromWskprops(t *testing.T) {
+    fakeProperties := FakePropertiesImp{
+        StoredValues_LOCAL_CONF: map[string]string {
+            WHISK_APIHOST: EXPECTED_API_HOST,
+            APIHOST: EXPECTED_HOST,
+            AUTH: EXPECTED_AUTH_API_KEY,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err := GetConfigFromWskprops(fakeProperties, "")
+    assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+    assert.Equal(t, EXPECTED_CERT, config.Cert)
+    assert.Equal(t, EXPECTED_KEY, config.Key)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
+    assert.Equal(t, EXPECTED_HOST, config.Host)
+    assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
+    assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+    assert.False(t, config.Verbose)
+    assert.False(t, config.Debug)
+    assert.True(t, config.Insecure)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: map[string]string {
+            APIHOST: EXPECTED_HOST,
+            AUTH: EXPECTED_AUTH_API_KEY,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err = GetConfigFromWskprops(fakeProperties, "")
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_URL)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: map[string]string {
+            WHISK_APIHOST: EXPECTED_API_HOST,
+            APIHOST: EXPECTED_HOST,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err = GetConfigFromWskprops(fakeProperties, "")
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_AUTH)
+}
+
+func TestGetConfigFromWhiskProperties(t *testing.T) {
+    fakeProperties := FakePropertiesImp{
+        StoredValues_WHISK: map[string]string {
+            WHISK_APIHOST: EXPECTED_API_HOST,
+            APIHOST: EXPECTED_HOST,
+            AUTH: EXPECTED_AUTH_API_KEY,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err := GetConfigFromWhiskProperties(fakeProperties)
+    assert.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
+    assert.Equal(t, EXPECTED_CERT, config.Cert)
+    assert.Equal(t, EXPECTED_KEY, config.Key)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY, config.AuthToken)
+    assert.Equal(t, EXPECTED_HOST, config.Host)
+    assert.Equal(t, EXPECTED_API_HOST, config.BaseURL.String())
+    assert.Equal(t, EXPECTED_API_VERSION, config.Version)
+    assert.False(t, config.Verbose)
+    assert.False(t, config.Debug)
+    assert.True(t, config.Insecure)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_WHISK: map[string]string {
+            APIHOST: EXPECTED_HOST,
+            AUTH: EXPECTED_AUTH_API_KEY,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err = GetConfigFromWhiskProperties(fakeProperties)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_URL)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_WHISK: map[string]string {
+            WHISK_APIHOST: EXPECTED_API_HOST,
+            APIHOST: EXPECTED_HOST,
+            NAMESPACE: DEFAULT_NAMESPACE,
+            APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY,
+            APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID,
+            APIVERSION: EXPECTED_API_VERSION,
+            CERT: EXPECTED_CERT,
+            KEY: EXPECTED_KEY,
+        },
+    }
+
+    config, err = GetConfigFromWhiskProperties(fakeProperties)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_AUTH)
+}
+
+func TestValidateWskprops(t *testing.T) {
+    dep := Wskprops {
+        WHISKAPIURL: "",
+        APIHost: "",
+        AuthKey: "",
+        Namespace: DEFAULT_NAMESPACE,
+        AuthAPIGWKey: "",
+        APIGWSpaceSuid: "",
+        Apiversion: DEFAULT_VERSION,
+        Key: "",
+        Cert: "",
+    }
+    err := ValidateWskprops(&dep)
+    assert.Contains(t, err.Error(), MISSING_URL)
+
+    dep = Wskprops {
+        WHISKAPIURL: "invalid_path",
+        APIHost: "",
+        AuthKey: "",
+        Namespace: DEFAULT_NAMESPACE,
+        AuthAPIGWKey: "",
+        APIGWSpaceSuid: "",
+        Apiversion: DEFAULT_VERSION,
+        Key: "",
+        Cert: "",
+    }
+    err = ValidateWskprops(&dep)
+    assert.Contains(t, err.Error(), INVALID_URL)
+
+    dep = Wskprops {
+        WHISKAPIURL: "http://localhost/api",
+        APIHost: "",
+        AuthKey: "",
+        Namespace: DEFAULT_NAMESPACE,
+        AuthAPIGWKey: "",
+        APIGWSpaceSuid: "",
+        Apiversion: DEFAULT_VERSION,
+        Key: "",
+        Cert: "",
+    }
+    err = ValidateWskprops(&dep)
+    assert.Contains(t, err.Error(), MISSING_AUTH)
+
+    dep = Wskprops {
+        WHISKAPIURL: "http://localhost/api",
+        APIHost: "",
+        AuthKey: "auth_key",
+        Namespace: DEFAULT_NAMESPACE,
+        AuthAPIGWKey: "",
+        APIGWSpaceSuid: "",
+        Apiversion: DEFAULT_VERSION,
+        Key: "",
+        Cert: "",
+    }
+    err = ValidateWskprops(&dep)
+    assert.Equal(t, nil, err)
+
+}
+
+func TestGetDefaultWskProp(t *testing.T) {
+    valid_whisk_values := map[string]string {
+        WHISK_APIHOST: EXPECTED_API_URL_WHISK,
+        APIHOST: EXPECTED_API_HOST_WHISK,
+        AUTH: EXPECTED_TEST_AUTH_KEY_WHISK,
+        NAMESPACE: EXPECTED_NAMESPACE_WHISK,
+        APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_WHISK,
+        APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_WHISK,
+        APIVERSION: EXPECTED_API_VERSION_WHISK,
+        CERT: EXPECTED_CERT_WHISK,
+        KEY: EXPECTED_KEY_WHISK,
+    }
+    valid_local_conf_values := map[string]string {
+        WHISK_APIHOST: EXPECTED_API_URL_LOCAL_CONF,
+        APIHOST: EXPECTED_API_HOST_LOCAL_CONF,
+        AUTH: EXPECTED_TEST_AUTH_KEY_LOCAL_CONF,
+        NAMESPACE: EXPECTED_NAMESPACE_LOCAL_CONF,
+        APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_LOCAL_CONF,
+        APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF,
+        APIVERSION: EXPECTED_API_VERSION_LOCAL_CONF,
+        CERT: EXPECTED_CERT_LOCAL_CONF,
+        KEY: EXPECTED_KEY_LOCAL_CONF,
+    }
+
+    missing_auth_local_conf_values := map[string]string{}
+    for k,v := range valid_local_conf_values {
+        if k != AUTH {
+            missing_auth_local_conf_values[k] = v
+        }
+    }
+
+    missing_url_local_conf_values := map[string]string{}
+    for k,v := range valid_local_conf_values {
+        if k != WHISK_APIHOST {
+            missing_url_local_conf_values[k] = v
+        }
+    }
+
+    missing_auth_whisk_values := map[string]string{}
+    for k,v := range valid_whisk_values {
+        if k != AUTH {
+            missing_auth_whisk_values[k] = v
+        }
+    }
+
+    missing_url_whisk_values := map[string]string{}
+    for k,v := range valid_whisk_values {
+        if k != WHISK_APIHOST {
+            missing_url_whisk_values[k] = v
+        }
+    }
+
+    fakeProperties := FakePropertiesImp{
+        StoredValues_WHISK: valid_whisk_values,
+    }
+    dep, err := GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_WHISK, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: valid_local_conf_values,
+    }
+    dep, err = GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_LOCAL_CONF, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: valid_local_conf_values,
+        StoredValues_WHISK: valid_whisk_values,
+    }
+    dep, err = GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_LOCAL_CONF, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: missing_url_local_conf_values,
+        StoredValues_WHISK: valid_whisk_values,
+    }
+    dep, err = GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_WHISK, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+        StoredValues_WHISK: valid_whisk_values,
+    }
+    dep, err = GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_WHISK, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+        StoredValues_WHISK: missing_auth_whisk_values,
+    }
+    dep, err = GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, "", dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.NotEqual(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+        StoredValues_WHISK: missing_url_whisk_values,
+    }
+    dep, err = GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, "", dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.NotEqual(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: missing_url_local_conf_values,
+        StoredValues_WHISK: missing_auth_whisk_values,
+    }
+    dep, err = GetDefaultWskProp(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.NotEqual(t, nil, err)
+
+}
+
+func TestGetWskPropFromWskprops(t *testing.T) {
+    valid_local_conf_values := map[string]string{
+        WHISK_APIHOST: EXPECTED_API_URL_LOCAL_CONF,
+        APIHOST: EXPECTED_API_HOST_LOCAL_CONF,
+        AUTH: EXPECTED_TEST_AUTH_KEY_LOCAL_CONF,
+        NAMESPACE: EXPECTED_NAMESPACE_LOCAL_CONF,
+        APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_LOCAL_CONF,
+        APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF,
+        APIVERSION: EXPECTED_API_VERSION_LOCAL_CONF,
+        CERT: EXPECTED_CERT_LOCAL_CONF,
+        KEY: EXPECTED_KEY_LOCAL_CONF,
+    }
+
+    missing_auth_local_conf_values := map[string]string{}
+    for k, v := range valid_local_conf_values {
+        if k != AUTH {
+            missing_auth_local_conf_values[k] = v
+        }
+    }
+
+    missing_url_local_conf_values := map[string]string{}
+    for k, v := range valid_local_conf_values {
+        if k != WHISK_APIHOST {
+            missing_url_local_conf_values[k] = v
+        }
+    }
+
+    fakeProperties := FakePropertiesImp{
+        StoredValues_LOCAL_CONF: valid_local_conf_values,
+    }
+
+    dep, err := GetWskPropFromWskprops(fakeProperties, "")
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_LOCAL_CONF, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: missing_url_local_conf_values,
+    }
+    dep, err = GetWskPropFromWskprops(fakeProperties, "")
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_LOCAL_CONF, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, "", dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_URL)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_LOCAL_CONF: missing_auth_local_conf_values,
+    }
+    dep, err = GetWskPropFromWskprops(fakeProperties, "")
+    assert.Equal(t, EXPECTED_NAMESPACE_LOCAL_CONF, dep.Namespace)
+    assert.Equal(t, "", dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_LOCAL_CONF, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_LOCAL_CONF, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_LOCAL_CONF, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_LOCAL_CONF, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_LOCAL_CONF, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_LOCAL_CONF, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_LOCAL_CONF, dep.Key)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_AUTH)
+}
+
+func TestGetWskPropFromWhiskProperty(t *testing.T) {
+    valid_whisk_values := map[string]string {
+        WHISK_APIHOST: EXPECTED_API_URL_WHISK,
+        APIHOST: EXPECTED_API_HOST_WHISK,
+        AUTH: EXPECTED_TEST_AUTH_KEY_WHISK,
+        NAMESPACE: EXPECTED_NAMESPACE_WHISK,
+        APIGW_ACCESS_TOKEN: EXPECTED_AUTH_API_KEY_WHISK,
+        APIGW_SPACE_SUID: EXPECTED_API_GW_SPACE_SUID_WHISK,
+        APIVERSION: EXPECTED_API_VERSION_WHISK,
+        CERT: EXPECTED_CERT_WHISK,
+        KEY: EXPECTED_KEY_WHISK,
+    }
+
+    missing_auth_whisk_values := map[string]string{}
+    for k,v := range valid_whisk_values {
+        if k != AUTH {
+            missing_auth_whisk_values[k] = v
+        }
+    }
+
+    missing_url_whisk_values := map[string]string{}
+    for k,v := range valid_whisk_values {
+        if k != WHISK_APIHOST {
+            missing_url_whisk_values[k] = v
+        }
+    }
+
+    invalid_url_whisk_values := map[string]string{}
+    for k,v := range valid_whisk_values {
+        invalid_url_whisk_values[k] = v
+    }
+    invalid_url_whisk_values[WHISK_APIHOST] = "invalid_url"
+
+    fakeProperties := FakePropertiesImp{
+        StoredValues_WHISK: valid_whisk_values,
+    }
+
+    dep, err := GetWskPropFromWhiskProperty(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_WHISK, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+    assert.Equal(t, nil, err)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_WHISK: missing_auth_whisk_values,
+    }
+
+    dep, err = GetWskPropFromWhiskProperty(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+    assert.Equal(t, "", dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+    assert.Equal(t, EXPECTED_API_URL_WHISK, dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_AUTH)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_WHISK: missing_url_whisk_values,
+    }
+
+    dep, err = GetWskPropFromWhiskProperty(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+    assert.Equal(t, "", dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), MISSING_URL)
+
+    fakeProperties = FakePropertiesImp{
+        StoredValues_WHISK: invalid_url_whisk_values,
+    }
+
+    dep, err = GetWskPropFromWhiskProperty(fakeProperties)
+    assert.Equal(t, EXPECTED_NAMESPACE_WHISK, dep.Namespace)
+    assert.Equal(t, EXPECTED_TEST_AUTH_KEY_WHISK, dep.AuthKey)
+    assert.Equal(t, EXPECTED_AUTH_API_KEY_WHISK, dep.AuthAPIGWKey)
+    assert.Equal(t, EXPECTED_API_HOST_WHISK, dep.APIHost)
+    assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
+    assert.Equal(t, "invalid_url", dep.WHISKAPIURL)
+    assert.Equal(t, EXPECTED_API_VERSION_WHISK, dep.Apiversion)
+    assert.Equal(t, EXPECTED_CERT_WHISK, dep.Cert)
+    assert.Equal(t, EXPECTED_KEY_WHISK, dep.Key)
+    assert.NotEqual(t, nil, err)
+    assert.Contains(t, err.Error(), INVALID_URL)
+}
diff --git a/wski18n/i18n_resources.go b/wski18n/i18n_resources.go
index 10fb30a..5a78473 100644
--- a/wski18n/i18n_resources.go
+++ b/wski18n/i18n_resources.go
@@ -15,11 +15,7 @@
  * limitations under the License.
  */
 
-// WARNING: This code is generated by go-bindata.
-// Anytime a translated string changes and this file
-// is regenerated, the ASF header must be added
-// manually and all TAB characters MUST be removed.
-//
+// Code generated by go-bindata.
 // sources:
 // wski18n/resources/de_DE.all.json
 // wski18n/resources/en_US.all.json
@@ -113,12 +109,12 @@ func wski18nResourcesDe_deAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/de_DE.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/de_DE.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
 
-var _wski18nResourcesEn_usAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x97\xc1\x6e\xdb\x3c\x0c\xc7\xef\x79\x0a\xc2\x97\xf4\x03\x5a\x3f\x40\xbf\xd3\xb0\x05\xdb\x80\x62\x2b\xb6\x74\x97\x75\x07\xd5\x62\x1a\x61\x8e\xe8\x52\x72\xba\x36\xd0\xbb\x0f\x92\xe3\xae\x43\xed\x58\x56\x3c\xa0\xa7\x16\x8a\xf8\xe7\x4f\x24\x25\xd2\xdf\x67\x00\xbb\x19\x00\x40\xa6\x64\x76\x0e\xd9\x95\x16\x37\x25\x82\x25\x10\x52\x02\x53\x6d\x11\xa8\xb2\x8a\xb4\x81\xf9\x6e\x97\xef\xff\x77\x6e\x9e\x9d\x36\x76 [...]
+var _wski18nResourcesEn_usAllJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x98\xdd\x72\xea\x36\x10\xc7\xef\x79\x8a\x1d\xdf\x40\x67\x38\x7e\x80\xd3\x2b\xa6\x65\x0a\xd3\xd3\xc0\x34\xd0\x5c\x34\x9d\x8e\x62\x2d\x58\x13\x23\x39\x2b\x19\x4a\x18\xbf\x7b\x47\x32\x24\x34\xd8\xf8\x03\x87\x72\xae\xc2\x28\xda\xff\xfe\x76\xb5\x92\x56\xfe\xb3\x03\xb0\xeb\x00\x00\x78\x82\x7b\x5f\xc1\x9b\x4b\xf6\x14\x21\x18\x05\x8c\x73\x20\x95\x18\x04\x15\x1b\xa1\xa4\x86\xee\x6e\xe7\xef\x7f\xa7\x69\xd7\xeb [...]
 
 func wski18nResourcesEn_usAllJsonBytes() ([]byte, error) {
     return bindataRead(
@@ -133,7 +129,7 @@ func wski18nResourcesEn_usAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/en_US.all.json", size: 4659, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/en_US.all.json", size: 6539, mode: os.FileMode(420), modTime: time.Unix(1503611107, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -153,7 +149,7 @@ func wski18nResourcesEs_esAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/es_ES.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/es_ES.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -173,7 +169,7 @@ func wski18nResourcesFr_frAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/fr_FR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/fr_FR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -193,7 +189,7 @@ func wski18nResourcesIt_itAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/it_IT.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/it_IT.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -213,7 +209,7 @@ func wski18nResourcesJa_jaAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/ja_JA.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/ja_JA.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -233,7 +229,7 @@ func wski18nResourcesKo_krAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/ko_KR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/ko_KR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -253,7 +249,7 @@ func wski18nResourcesPt_brAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/pt_BR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/pt_BR.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -273,7 +269,7 @@ func wski18nResourcesZh_hansAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/zh_Hans.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/zh_Hans.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
@@ -293,7 +289,7 @@ func wski18nResourcesZh_hantAllJson() (*asset, error) {
         return nil, err
     }
 
-    info := bindataFileInfo{name: "wski18n/resources/zh_Hant.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1502918884, 0)}
+    info := bindataFileInfo{name: "wski18n/resources/zh_Hant.all.json", size: 0, mode: os.FileMode(420), modTime: time.Unix(1500156160, 0)}
     a := &asset{bytes: bytes, info: info}
     return a, nil
 }
diff --git a/wski18n/resources/en_US.all.json b/wski18n/resources/en_US.all.json
index e473202..762829d 100644
--- a/wski18n/resources/en_US.all.json
+++ b/wski18n/resources/en_US.all.json
@@ -122,5 +122,29 @@
   {
     "id": "The connection failed, or timed out. (HTTP status code {{.code}})",
     "translation": "The connection failed, or timed out. (HTTP status code {{.code}})"
+  },
+  {
+    "id": "OpenWhisk API URL is missing (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)",
+    "translation": "OpenWhisk API URL is missing (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)"
+  },
+  {
+    "id": "OpenWhisk API URL is missing (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)",
+    "translation": "OpenWhisk API URL is missing (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)"
+  },
+  {
+    "id": "Invalid OpenWhisk API URL (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)",
+    "translation": "Invalid OpenWhisk API URL (Please configure WHISK_APIHOST in .wskprops under the system HOME directory.)"
+  },
+  {
+    "id": "Invalid OpenWhisk API URL (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)",
+    "translation": "Invalid OpenWhisk API URL (Please configure whisk.api.host.proto, whisk.api.host.name and whisk.api.host.port in whisk.properties under the OPENWHISK_HOME directory.)"
+  },
+  {
+    "id": "Authentication key is missing (Please configure AUTH in .wskprops under the system HOME directory.)",
+    "translation": "Authentication key is missing (Please configure AUTH in .wskprops under the system HOME directory.)"
+  },
+  {
+    "id": "Authentication key is missing (Please configure testing.auth as the path of the authentication key file in whisk.properties under the OPENWHISK_HOME directory.)",
+    "translation": "Authentication key is missing (Please configure testing.auth as the path of the authentication key file in whisk.properties under the OPENWHISK_HOME directory.)"
   }
 ]

-- 
To stop receiving notification emails like this one, please contact
['"commits@openwhisk.apache.org" <commits@openwhisk.apache.org>'].

Mime
View raw message