whisk/wskprops_test.go

// +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 (
	"bufio"
	"fmt"
	"github.com/stretchr/testify/assert"
	"os"
	"testing"
)

const (
	TEST_AUTH_FILE_NAME        = "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 + "/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"
	EXPECTED_APIGW_TENANT_ID   = "crn:v1:providername:public:servicename:region:a/1234567890abcdef0987654321fedcba:faaa50ec-dce9-4a23-9aaa-a8cb5c7648dc::"
	APIGW_SPACE_SUID           = "APIGW_SPACE_SUID"
	EXPECTED_API_VERSION       = "v1"
	EXPECTED_CERT              = "EXPECTED_CERT"
	EXPECTED_KEY               = "EXPECTED_KEY"

	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_HOST_LOCAL_CONF          = "hostname"
	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_MESSAGE = "Authentication key is missing"
	MISSING_URL_MESSAGE  = "OpenWhisk API host is missing"
)

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/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{
		APIGWSpaceSuid: GetValue(pi.StoredValues_LOCAL_CONF, APIGW_SPACE_SUID, ""),
		APIGWTenantId:  GetValue(pi.StoredValues_LOCAL_CONF, APIGW_TENANT_ID, ""),
		APIHost:        GetValue(pi.StoredValues_LOCAL_CONF, APIHOST, ""),
		Apiversion:     GetValue(pi.StoredValues_LOCAL_CONF, APIVERSION, ""),
		AuthAPIGWKey:   GetValue(pi.StoredValues_LOCAL_CONF, APIGW_ACCESS_TOKEN, ""),
		AuthKey:        GetValue(pi.StoredValues_LOCAL_CONF, AUTH, ""),
		Cert:           GetValue(pi.StoredValues_LOCAL_CONF, CERT, ""),
		Key:            GetValue(pi.StoredValues_LOCAL_CONF, KEY, ""),
		Namespace:      GetValue(pi.StoredValues_LOCAL_CONF, NAMESPACE, ""),
	}
	return &dep
}

func (pi FakePropertiesImp) GetPropsFromWhiskProperties() *Wskprops {
	dep := Wskprops{
		APIGWSpaceSuid: pi.StoredValues_WHISK[APIGW_SPACE_SUID],
		APIGWTenantId:  pi.StoredValues_WHISK[APIGW_TENANT_ID],
		APIHost:        pi.StoredValues_WHISK[APIHOST],
		Apiversion:     pi.StoredValues_WHISK[APIVERSION],
		AuthAPIGWKey:   pi.StoredValues_WHISK[APIGW_ACCESS_TOKEN],
		AuthKey:        pi.StoredValues_WHISK[AUTH],
		Cert:           pi.StoredValues_WHISK[CERT],
		Key:            pi.StoredValues_WHISK[KEY],
		Namespace:      pi.StoredValues_WHISK[NAMESPACE],
	}
	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) {

	// Variant 1 ------------------------------------------------------------------
	lines := []string{EXPECTED_TEST_AUTH_KEY}
	CreateFile(lines, TEST_AUTH_FILE_NAME)

	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, WHISK_PROPERTY, dep.Source)

	// Variant 2 ------------------------------------------------------------------
	lines = []string{
		OPENWHISK_HOST + "=" + EXPECTED_OPENWHISK_HOST,
		OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
		OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
		TEST_AUTH_FILE + "=" + TEST_AUTH_FILE_NAME,
	}
	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_OPENWHISK_HOST, dep.APIHost)
	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(TEST_AUTH_FILE_NAME)
	// Make sure the "non-existant" test.auth key file really does not exist
	DeleteFile(NON_EXISTING_TEST_FILE)

	// Variant 3 ------------------------------------------------------------------
	lines = []string{
		OPENWHISK_HOST + "=" + EXPECTED_OPENWHISK_HOST,
		OPENWHISK_PORT + "=" + EXPECTED_OPENWHISK_PORT,
		OPENWHISK_PRO + "=" + EXPECTED_OPENWHISK_PRO,
		TEST_AUTH_FILE + "=" + NON_EXISTING_TEST_FILE,
	}

	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_OPENWHISK_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)
}

func TestGetPropsFromWskprops(t *testing.T) {
	lines := []string{
		APIGW_ACCESS_TOKEN + "=" + EXPECTED_AUTH_API_KEY,
		APIGW_TENANT_ID + "=" + EXPECTED_APIGW_TENANT_ID,
		APIHOST + "=" + EXPECTED_HOST,
		APIVERSION + "=" + EXPECTED_API_VERSION,
		AUTH + "=" + EXPECTED_TEST_AUTH_KEY,
		CERT + "=" + EXPECTED_CERT,
		KEY + "=" + EXPECTED_KEY,
		NAMESPACE + "=" + DEFAULT_NAMESPACE,
	}

	CreateFile(lines, DEFAULT_LOCAL_CONFIG)

	fakeOSPackage := FakeOSPackage{
		StoredValues: map[string]string{
			HOMEPATH: 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_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() + "/" + DEFAULT_LOCAL_CONFIG
	dep = pi.GetPropsFromWskprops(path)
	assert.Equal(t, DEFAULT_NAMESPACE, dep.Namespace)
	assert.Equal(t, EXPECTED_API_GW_SPACE_SUID, dep.APIGWSpaceSuid)
	assert.Equal(t, EXPECTED_APIGW_TENANT_ID, dep.APIGWTenantId)
	assert.Equal(t, EXPECTED_API_VERSION, dep.Apiversion)
	assert.Equal(t, EXPECTED_AUTH_API_KEY, dep.AuthAPIGWKey)
	assert.Equal(t, EXPECTED_CERT, dep.Cert)
	assert.Equal(t, EXPECTED_HOST, dep.APIHost)
	assert.Equal(t, EXPECTED_KEY, dep.Key)
	assert.Equal(t, EXPECTED_TEST_AUTH_KEY, dep.AuthKey)
	assert.Equal(t, WSKPROP, dep.Source)

	DeleteFile(DEFAULT_LOCAL_CONFIG)
}

func TestGetDefaultConfigFromProperties(t *testing.T) {
	fakeProperties := FakePropertiesImp{
		StoredValues_LOCAL_CONF: map[string]string{
			APIHOST:            EXPECTED_OPENWHISK_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_OPENWHISK_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{
			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, "", config.Host)
	assert.Nil(t, config.BaseURL)
	assert.Equal(t, EXPECTED_API_VERSION, config.Version)
	assert.False(t, config.Verbose)
	assert.False(t, config.Debug)
	assert.True(t, config.Insecure)
	assert.NotEqual(t, nil, err)
	assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)

	fakeProperties = FakePropertiesImp{
		StoredValues_LOCAL_CONF: map[string]string{
			APIHOST:            EXPECTED_OPENWHISK_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.Equal(t, DEFAULT_NAMESPACE, config.Namespace)
	assert.Equal(t, EXPECTED_CERT, config.Cert)
	assert.Equal(t, EXPECTED_KEY, config.Key)
	assert.Equal(t, "", config.AuthToken)
	assert.Equal(t, EXPECTED_OPENWHISK_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.NotEqual(t, nil, err)
	assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)
}

func TestGetConfigFromWskprops(t *testing.T) {
	fakeProperties := FakePropertiesImp{
		StoredValues_LOCAL_CONF: map[string]string{
			APIHOST:            EXPECTED_OPENWHISK_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_OPENWHISK_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{
			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_MESSAGE)

	fakeProperties = FakePropertiesImp{
		StoredValues_LOCAL_CONF: map[string]string{
			APIHOST:            EXPECTED_OPENWHISK_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_MESSAGE)
}

func TestGetConfigFromWhiskProperties(t *testing.T) {
	fakeProperties := FakePropertiesImp{
		StoredValues_WHISK: map[string]string{
			APIHOST:            EXPECTED_OPENWHISK_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_OPENWHISK_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{
			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_MESSAGE)

	fakeProperties = FakePropertiesImp{
		StoredValues_WHISK: map[string]string{
			APIHOST:            EXPECTED_OPENWHISK_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_MESSAGE)
}

func TestValidateWskprops(t *testing.T) {
	dep := Wskprops{
		AuthKey:        "",
		Namespace:      DEFAULT_NAMESPACE,
		AuthAPIGWKey:   "",
		APIGWSpaceSuid: "",
		Apiversion:     DEFAULT_VERSION,
		Key:            "",
		Cert:           "",
	}
	err := ValidateWskprops(&dep)
	assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)

	dep = Wskprops{
		APIHost:        EXPECTED_OPENWHISK_HOST,
		AuthKey:        "",
		Namespace:      DEFAULT_NAMESPACE,
		AuthAPIGWKey:   "",
		APIGWSpaceSuid: "",
		Apiversion:     DEFAULT_VERSION,
		Key:            "",
		Cert:           "",
	}
	err = ValidateWskprops(&dep)
	assert.Contains(t, err.Error(), MISSING_AUTH_MESSAGE)

	dep = Wskprops{
		APIHost:        EXPECTED_OPENWHISK_HOST,
		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{
		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{
		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 != 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 != 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_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_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_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_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_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, "", 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{
		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 != 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_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, "", 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)
	assert.Contains(t, err.Error(), MISSING_URL_MESSAGE)

	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_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_MESSAGE)
}

func TestGetWskPropFromWhiskProperty(t *testing.T) {
	valid_whisk_values := map[string]string{
		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 != APIHOST {
			missing_url_whisk_values[k] = v
		}
	}

	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_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_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_MESSAGE)

	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, "", dep.APIHost)
	assert.Equal(t, EXPECTED_API_GW_SPACE_SUID_WHISK, dep.APIGWSpaceSuid)
	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_MESSAGE)

}