/*
Copyright 2014 The Kubernetes Authors.

Licensed 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 clientcmd

import (
	"fmt"
	"testing"

	restclient "k8s.io/client-go/rest"
	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
)

type testClientConfig struct {
	rawconfig          *clientcmdapi.Config
	config             *restclient.Config
	namespace          string
	namespaceSpecified bool
	err                error
}

func (c *testClientConfig) RawConfig() (clientcmdapi.Config, error) {
	if c.rawconfig == nil {
		return clientcmdapi.Config{}, fmt.Errorf("unexpected call")
	}
	return *c.rawconfig, nil
}
func (c *testClientConfig) ClientConfig() (*restclient.Config, error) {
	return c.config, c.err
}
func (c *testClientConfig) Namespace() (string, bool, error) {
	return c.namespace, c.namespaceSpecified, c.err
}
func (c *testClientConfig) ConfigAccess() ConfigAccess {
	return nil
}

type testICC struct {
	testClientConfig

	possible bool
	called   bool
}

func (icc *testICC) Possible() bool {
	icc.called = true
	return icc.possible
}

func TestInClusterConfig(t *testing.T) {
	default1 := &DirectClientConfig{
		config:      *createValidTestConfig(),
		contextName: "clean",
		overrides:   &ConfigOverrides{},
	}
	invalidDefaultConfig := clientcmdapi.NewConfig()
	invalidDefaultConfig.Clusters["clean"] = &clientcmdapi.Cluster{
		Server: "http://localhost:8080",
	}
	invalidDefaultConfig.Contexts["other"] = &clientcmdapi.Context{
		Cluster: "clean",
	}
	invalidDefaultConfig.CurrentContext = "clean"

	defaultInvalid := &DirectClientConfig{
		config:    *invalidDefaultConfig,
		overrides: &ConfigOverrides{},
	}
	if _, err := defaultInvalid.ClientConfig(); err == nil || !IsConfigurationInvalid(err) {
		t.Fatal(err)
	}
	config1, err := default1.ClientConfig()
	if err != nil {
		t.Fatal(err)
	}
	config2 := &restclient.Config{Host: "config2"}
	err1 := fmt.Errorf("unique error")

	testCases := map[string]struct {
		clientConfig  *testClientConfig
		icc           *testICC
		defaultConfig *DirectClientConfig

		checkedICC bool
		result     *restclient.Config
		err        error
	}{
		"in-cluster checked on other error": {
			clientConfig: &testClientConfig{err: ErrEmptyConfig},
			icc:          &testICC{},

			checkedICC: true,
			result:     nil,
			err:        ErrEmptyConfig,
		},

		"in-cluster not checked on non-empty error": {
			clientConfig: &testClientConfig{err: ErrEmptyCluster},
			icc:          &testICC{},

			checkedICC: false,
			result:     nil,
			err:        ErrEmptyCluster,
		},

		"in-cluster checked when config is default": {
			defaultConfig: default1,
			clientConfig:  &testClientConfig{config: config1},
			icc:           &testICC{},

			checkedICC: true,
			result:     config1,
			err:        nil,
		},

		"in-cluster not checked when default config is invalid": {
			defaultConfig: defaultInvalid,
			clientConfig:  &testClientConfig{config: config1},
			icc:           &testICC{},

			checkedICC: false,
			result:     config1,
			err:        nil,
		},

		"in-cluster not checked when config is not equal to default": {
			defaultConfig: default1,
			clientConfig:  &testClientConfig{config: config2},
			icc:           &testICC{},

			checkedICC: false,
			result:     config2,
			err:        nil,
		},

		"in-cluster checked when config is not equal to default and error is empty": {
			clientConfig: &testClientConfig{config: config2, err: ErrEmptyConfig},
			icc:          &testICC{},

			checkedICC: true,
			result:     config2,
			err:        ErrEmptyConfig,
		},

		"in-cluster error returned when config is empty": {
			clientConfig: &testClientConfig{err: ErrEmptyConfig},
			icc: &testICC{
				possible: true,
				testClientConfig: testClientConfig{
					err: err1,
				},
			},

			checkedICC: true,
			result:     nil,
			err:        err1,
		},

		"in-cluster config returned when config is empty": {
			clientConfig: &testClientConfig{err: ErrEmptyConfig},
			icc: &testICC{
				possible: true,
				testClientConfig: testClientConfig{
					config: config2,
				},
			},

			checkedICC: true,
			result:     config2,
			err:        nil,
		},

		"in-cluster not checked when standard default is invalid": {
			defaultConfig: &DefaultClientConfig,
			clientConfig:  &testClientConfig{config: config2},
			icc:           &testICC{},

			checkedICC: false,
			result:     config2,
			err:        nil,
		},
	}

	for name, test := range testCases {
		c := &DeferredLoadingClientConfig{icc: test.icc}
		c.loader = &ClientConfigLoadingRules{DefaultClientConfig: test.defaultConfig}
		c.clientConfig = test.clientConfig

		cfg, err := c.ClientConfig()
		if test.icc.called != test.checkedICC {
			t.Errorf("%s: unexpected in-cluster-config call %t", name, test.icc.called)
		}
		if err != test.err || cfg != test.result {
			t.Errorf("%s: unexpected result: %v %#v", name, err, cfg)
		}
	}
}

func TestInClusterConfigNamespace(t *testing.T) {
	err1 := fmt.Errorf("unique error")

	testCases := map[string]struct {
		clientConfig *testClientConfig
		icc          *testICC
		overrides    *ConfigOverrides

		checkedICC bool
		result     string
		overridden bool
		err        error
	}{
		"in-cluster checked on empty error": {
			clientConfig: &testClientConfig{err: ErrEmptyConfig},
			icc:          &testICC{},

			checkedICC: true,
			err:        ErrEmptyConfig,
		},

		"in-cluster not checked on non-empty error": {
			clientConfig: &testClientConfig{err: ErrEmptyCluster},
			icc:          &testICC{},

			err: ErrEmptyCluster,
		},

		"in-cluster checked when config is default": {
			clientConfig: &testClientConfig{},
			icc:          &testICC{},

			checkedICC: true,
		},

		"in-cluster not checked when config is not equal to default": {
			clientConfig: &testClientConfig{namespace: "test", namespaceSpecified: true},
			icc:          &testICC{},

			result:     "test",
			overridden: true,
		},

		"in-cluster checked when namespace is not specified, but is defaulted": {
			clientConfig: &testClientConfig{namespace: "test", namespaceSpecified: false},
			icc:          &testICC{},

			checkedICC: true,
			result:     "test",
			overridden: false,
		},

		"in-cluster error returned when config is empty": {
			clientConfig: &testClientConfig{err: ErrEmptyConfig},
			icc: &testICC{
				possible: true,
				testClientConfig: testClientConfig{
					err: err1,
				},
			},

			checkedICC: true,
			err:        err1,
		},

		"in-cluster config returned when config is empty": {
			clientConfig: &testClientConfig{err: ErrEmptyConfig},
			icc: &testICC{
				possible: true,
				testClientConfig: testClientConfig{
					namespace:          "test",
					namespaceSpecified: true,
				},
			},

			checkedICC: true,
			result:     "test",
			overridden: true,
		},

		"in-cluster config returned when config is empty and namespace is defaulted but not explicitly set": {
			clientConfig: &testClientConfig{err: ErrEmptyConfig},
			icc: &testICC{
				possible: true,
				testClientConfig: testClientConfig{
					namespace:          "test",
					namespaceSpecified: false,
				},
			},

			checkedICC: true,
			result:     "test",
			overridden: false,
		},

		"overridden context used to verify explicit namespace in config": {
			clientConfig: &testClientConfig{
				namespace:          "default",
				namespaceSpecified: false, // a namespace that comes from a context is not considered overridden
				rawconfig:          &clientcmdapi.Config{Contexts: map[string]*clientcmdapi.Context{"overridden-context": {Namespace: "default"}}},
			},
			overrides: &ConfigOverrides{CurrentContext: "overridden-context"},
			icc: &testICC{
				possible: true,
				testClientConfig: testClientConfig{
					namespace:          "icc",
					namespaceSpecified: false, // a namespace that comes from icc is not considered overridden
				},
			},
			checkedICC: true,
			result:     "default",
			overridden: false, // a namespace that comes from a context is not considered overridden
		},
	}

	for name, test := range testCases {
		t.Run(name, func(t *testing.T) {
			c := &DeferredLoadingClientConfig{icc: test.icc, overrides: test.overrides}
			c.clientConfig = test.clientConfig

			ns, overridden, err := c.Namespace()
			if test.icc.called != test.checkedICC {
				t.Errorf("%s: unexpected in-cluster-config call %t", name, test.icc.called)
			}
			if err != test.err || ns != test.result || overridden != test.overridden {
				t.Errorf("%s: unexpected result: %v %s %t", name, err, ns, overridden)
			}
		})
	}
}