kubernetes: k8s.io/kubernetes/staging/src/k8s.io/kubectl/pkg/cmd/config Index | Examples | Files

package config

import "k8s.io/kubernetes/staging/src/k8s.io/kubectl/pkg/cmd/config"

Code:

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "path"
    "reflect"
    "strings"
    "testing"

    apiequality "k8s.io/apimachinery/pkg/api/equality"
    "k8s.io/apimachinery/pkg/util/diff"
    "k8s.io/cli-runtime/pkg/genericclioptions"
    "k8s.io/client-go/tools/clientcmd"
    clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
    cmdutil "k8s.io/kubectl/pkg/cmd/util"
)

func newRedFederalCowHammerConfig() clientcmdapi.Config {
    return clientcmdapi.Config{
        AuthInfos: map[string]*clientcmdapi.AuthInfo{
            "red-user": {Token: "red-token"}},
        Clusters: map[string]*clientcmdapi.Cluster{
            "cow-cluster": {Server: "http://cow.org:8080"}},
        Contexts: map[string]*clientcmdapi.Context{
            "federal-context": {AuthInfo: "red-user", Cluster: "cow-cluster"}},
        CurrentContext: "federal-context",
    }
}

func main() {
    expectedConfig := newRedFederalCowHammerConfig()
    test := configCommandTest{
        args:           []string{"view"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    output := test.run(nil)
    fmt.Printf("%v", output)
}

func TestCurrentContext(t *testing.T) {
    startingConfig := newRedFederalCowHammerConfig()
    test := configCommandTest{
        args:            []string{"current-context"},
        startingConfig:  startingConfig,
        expectedConfig:  startingConfig,
        expectedOutputs: []string{startingConfig.CurrentContext},
    }
    test.run(t)
}

func TestSetCurrentContext(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    startingConfig := newRedFederalCowHammerConfig()

    newContextName := "the-new-context"

    startingConfig.Contexts[newContextName] = clientcmdapi.NewContext()
    expectedConfig.Contexts[newContextName] = clientcmdapi.NewContext()

    expectedConfig.CurrentContext = newContextName

    test := configCommandTest{
        args:           []string{"use-context", "the-new-context"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestSetNonExistentContext(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()

    test := configCommandTest{
        args:           []string{"use-context", "non-existent-config"},
        startingConfig: expectedConfig,
        expectedConfig: expectedConfig,
    }

    func() {
        defer func() {
            // Restore cmdutil behavior.
            cmdutil.DefaultBehaviorOnFatal()
        }()

        // Check exit code.
        cmdutil.BehaviorOnFatal(func(e string, code int) {
            if code != 1 {
                t.Errorf("The exit code is %d, expected 1", code)
            }
            expectedOutputs := []string{`no context exists with the name: "non-existent-config"`}
            test.checkOutput(e, expectedOutputs, t)
        })

        test.run(t)
    }()
}

func TestSetIntoExistingStruct(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.AuthInfos["red-user"].Password = "new-path-value" // Fake value for testing.
    test := configCommandTest{
        args:           []string{"set", "users.red-user.password", "new-path-value"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestSetWithPathPrefixIntoExistingStruct(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["cow-cluster"].Server = "http://cow.org:8080/foo/baz"
    test := configCommandTest{
        args:           []string{"set", "clusters.cow-cluster.server", "http://cow.org:8080/foo/baz"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)

    dc := clientcmd.NewDefaultClientConfig(expectedConfig, &clientcmd.ConfigOverrides{})
    dcc, err := dc.ClientConfig()
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    expectedHost := "http://cow.org:8080/foo/baz"
    if expectedHost != dcc.Host {
        t.Fatalf("expected client.Config.Host = %q instead of %q", expectedHost, dcc.Host)
    }
}

func TestUnsetStruct(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    delete(expectedConfig.AuthInfos, "red-user")
    test := configCommandTest{
        args:           []string{"unset", "users.red-user"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestUnsetField(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.AuthInfos["red-user"] = clientcmdapi.NewAuthInfo()
    test := configCommandTest{
        args:           []string{"unset", "users.red-user.token"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestSetIntoNewStruct(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    cluster := clientcmdapi.NewCluster()
    cluster.Server = "new-server-value"
    expectedConfig.Clusters["big-cluster"] = cluster
    test := configCommandTest{
        args:           []string{"set", "clusters.big-cluster.server", "new-server-value"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestSetBoolean(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    cluster := clientcmdapi.NewCluster()
    cluster.InsecureSkipTLSVerify = true
    expectedConfig.Clusters["big-cluster"] = cluster
    test := configCommandTest{
        args:           []string{"set", "clusters.big-cluster.insecure-skip-tls-verify", "true"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestSetIntoNewConfig(t *testing.T) {
    expectedConfig := *clientcmdapi.NewConfig()
    context := clientcmdapi.NewContext()
    context.AuthInfo = "fake-user"
    expectedConfig.Contexts["new-context"] = context
    test := configCommandTest{
        args:           []string{"set", "contexts.new-context.user", "fake-user"},
        startingConfig: *clientcmdapi.NewConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestNewEmptyAuth(t *testing.T) {
    expectedConfig := *clientcmdapi.NewConfig()
    expectedConfig.AuthInfos["the-user-name"] = clientcmdapi.NewAuthInfo()
    test := configCommandTest{
        args:           []string{"set-credentials", "the-user-name"},
        startingConfig: *clientcmdapi.NewConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestAdditionalAuth(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    authInfo := clientcmdapi.NewAuthInfo()
    authInfo.Token = "token"
    expectedConfig.AuthInfos["another-user"] = authInfo
    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagBearerToken + "=token"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestEmbedClientCert(t *testing.T) {
    fakeCertFile, _ := ioutil.TempFile(os.TempDir(), "")
    defer os.Remove(fakeCertFile.Name())
    fakeData := []byte("fake-data")
    ioutil.WriteFile(fakeCertFile.Name(), fakeData, 0600)
    expectedConfig := newRedFederalCowHammerConfig()
    authInfo := clientcmdapi.NewAuthInfo()
    authInfo.ClientCertificateData = fakeData
    expectedConfig.AuthInfos["another-user"] = authInfo

    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagCertFile + "=" + fakeCertFile.Name(), "--" + clientcmd.FlagEmbedCerts + "=true"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestEmbedClientKey(t *testing.T) {
    fakeKeyFile, _ := ioutil.TempFile(os.TempDir(), "")
    defer os.Remove(fakeKeyFile.Name())
    fakeData := []byte("fake-data")
    ioutil.WriteFile(fakeKeyFile.Name(), fakeData, 0600)
    expectedConfig := newRedFederalCowHammerConfig()
    authInfo := clientcmdapi.NewAuthInfo()
    authInfo.ClientKeyData = fakeData
    expectedConfig.AuthInfos["another-user"] = authInfo

    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagKeyFile + "=" + fakeKeyFile.Name(), "--" + clientcmd.FlagEmbedCerts + "=true"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestEmbedNoKeyOrCertDisallowed(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagEmbedCerts + "=true"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    func() {
        defer func() {
            // Restore cmdutil behavior.
            cmdutil.DefaultBehaviorOnFatal()
        }()

        // Check exit code.
        cmdutil.BehaviorOnFatal(func(e string, code int) {
            if code != 1 {
                t.Errorf("The exit code is %d, expected 1", code)
            }
            expectedOutputs := []string{"--client-certificate", "--client-key", "embed"}
            test.checkOutput(e, expectedOutputs, t)
        })

        test.run(t)
    }()
}

func TestEmptyTokenAndCertAllowed(t *testing.T) {
    fakeCertFile, _ := ioutil.TempFile(os.TempDir(), "cert-file")
    defer os.Remove(fakeCertFile.Name())
    expectedConfig := newRedFederalCowHammerConfig()
    authInfo := clientcmdapi.NewAuthInfo()
    authInfo.ClientCertificate = path.Base(fakeCertFile.Name())
    expectedConfig.AuthInfos["another-user"] = authInfo

    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagCertFile + "=" + fakeCertFile.Name(), "--" + clientcmd.FlagBearerToken + "="},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestTokenAndCertAllowed(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    authInfo := clientcmdapi.NewAuthInfo()
    authInfo.Token = "token"
    authInfo.ClientCertificate = "/cert-file"
    expectedConfig.AuthInfos["another-user"] = authInfo
    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagCertFile + "=/cert-file", "--" + clientcmd.FlagBearerToken + "=token"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestTokenAndBasicDisallowed(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagUsername + "=myuser", "--" + clientcmd.FlagBearerToken + "=token"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    func() {
        defer func() {
            // Restore cmdutil behavior.
            cmdutil.DefaultBehaviorOnFatal()
        }()

        // Check exit code.
        cmdutil.BehaviorOnFatal(func(e string, code int) {
            if code != 1 {
                t.Errorf("The exit code is %d, expected 1", code)
            }

            expectedOutputs := []string{"--token", "--username"}
            test.checkOutput(e, expectedOutputs, t)
        })

        test.run(t)
    }()
}

func TestBasicClearsToken(t *testing.T) {
    authInfoWithToken := clientcmdapi.NewAuthInfo()
    authInfoWithToken.Token = "token"

    authInfoWithBasic := clientcmdapi.NewAuthInfo()
    authInfoWithBasic.Username = "myuser"
    authInfoWithBasic.Password = "mypass" // Fake value for testing.

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.AuthInfos["another-user"] = authInfoWithToken

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.AuthInfos["another-user"] = authInfoWithBasic

    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagUsername + "=myuser", "--" + clientcmd.FlagPassword + "=mypass"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestTokenClearsBasic(t *testing.T) {
    authInfoWithBasic := clientcmdapi.NewAuthInfo()
    authInfoWithBasic.Username = "myuser"
    authInfoWithBasic.Password = "mypass" // Fake value for testing.

    authInfoWithToken := clientcmdapi.NewAuthInfo()
    authInfoWithToken.Token = "token"

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.AuthInfos["another-user"] = authInfoWithBasic

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.AuthInfos["another-user"] = authInfoWithToken

    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagBearerToken + "=token"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestTokenLeavesCert(t *testing.T) {
    authInfoWithCerts := clientcmdapi.NewAuthInfo()
    authInfoWithCerts.ClientCertificate = "cert"
    authInfoWithCerts.ClientCertificateData = []byte("certdata")
    authInfoWithCerts.ClientKey = "key"
    authInfoWithCerts.ClientKeyData = []byte("keydata")

    authInfoWithTokenAndCerts := clientcmdapi.NewAuthInfo()
    authInfoWithTokenAndCerts.Token = "token"
    authInfoWithTokenAndCerts.ClientCertificate = "cert"
    authInfoWithTokenAndCerts.ClientCertificateData = []byte("certdata")
    authInfoWithTokenAndCerts.ClientKey = "key"
    authInfoWithTokenAndCerts.ClientKeyData = []byte("keydata")

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.AuthInfos["another-user"] = authInfoWithCerts

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.AuthInfos["another-user"] = authInfoWithTokenAndCerts

    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagBearerToken + "=token"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestCertLeavesToken(t *testing.T) {
    authInfoWithToken := clientcmdapi.NewAuthInfo()
    authInfoWithToken.Token = "token"

    authInfoWithTokenAndCerts := clientcmdapi.NewAuthInfo()
    authInfoWithTokenAndCerts.Token = "token"
    authInfoWithTokenAndCerts.ClientCertificate = "/cert"
    authInfoWithTokenAndCerts.ClientKey = "/key"

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.AuthInfos["another-user"] = authInfoWithToken

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.AuthInfos["another-user"] = authInfoWithTokenAndCerts

    test := configCommandTest{
        args:           []string{"set-credentials", "another-user", "--" + clientcmd.FlagCertFile + "=/cert", "--" + clientcmd.FlagKeyFile + "=/key"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestSetBytesBad(t *testing.T) {
    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clientcmdapi.NewCluster()

    test := configCommandTest{
        args:           []string{"set", "clusters.another-cluster.certificate-authority-data", "cadata"},
        startingConfig: startingConfig,
        expectedConfig: startingConfig,
    }

    func() {
        defer func() {
            // Restore cmdutil behavior.
            cmdutil.DefaultBehaviorOnFatal()
        }()

        // Check exit code.
        cmdutil.BehaviorOnFatal(func(e string, code int) {
            if code != 1 {
                t.Errorf("The exit code is %d, expected 1", code)
            }
        })

        test.run(t)
    }()
}

func TestSetBytes(t *testing.T) {
    clusterInfoWithCAData := clientcmdapi.NewCluster()
    clusterInfoWithCAData.CertificateAuthorityData = []byte("cadata")

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clientcmdapi.NewCluster()

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["another-cluster"] = clusterInfoWithCAData

    test := configCommandTest{
        args:           []string{"set", "clusters.another-cluster.certificate-authority-data", "cadata", "--set-raw-bytes"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestSetBase64Bytes(t *testing.T) {
    clusterInfoWithCAData := clientcmdapi.NewCluster()
    clusterInfoWithCAData.CertificateAuthorityData = []byte("cadata")

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clientcmdapi.NewCluster()

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["another-cluster"] = clusterInfoWithCAData

    test := configCommandTest{
        args:           []string{"set", "clusters.another-cluster.certificate-authority-data", "Y2FkYXRh"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestUnsetBytes(t *testing.T) {
    clusterInfoWithCAData := clientcmdapi.NewCluster()
    clusterInfoWithCAData.CertificateAuthorityData = []byte("cadata")

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clusterInfoWithCAData

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["another-cluster"] = clientcmdapi.NewCluster()

    test := configCommandTest{
        args:           []string{"unset", "clusters.another-cluster.certificate-authority-data"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestCAClearsInsecure(t *testing.T) {
    fakeCAFile, _ := ioutil.TempFile(os.TempDir(), "ca-file")
    defer os.Remove(fakeCAFile.Name())
    clusterInfoWithInsecure := clientcmdapi.NewCluster()
    clusterInfoWithInsecure.InsecureSkipTLSVerify = true

    clusterInfoWithCA := clientcmdapi.NewCluster()
    clusterInfoWithCA.CertificateAuthority = path.Base(fakeCAFile.Name())

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clusterInfoWithInsecure

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["another-cluster"] = clusterInfoWithCA

    test := configCommandTest{
        args:           []string{"set-cluster", "another-cluster", "--" + clientcmd.FlagCAFile + "=" + fakeCAFile.Name()},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestCAClearsCAData(t *testing.T) {
    clusterInfoWithCAData := clientcmdapi.NewCluster()
    clusterInfoWithCAData.CertificateAuthorityData = []byte("cadata")

    clusterInfoWithCA := clientcmdapi.NewCluster()
    clusterInfoWithCA.CertificateAuthority = "/cafile"

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clusterInfoWithCAData

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["another-cluster"] = clusterInfoWithCA

    test := configCommandTest{
        args:           []string{"set-cluster", "another-cluster", "--" + clientcmd.FlagCAFile + "=/cafile", "--" + clientcmd.FlagInsecure + "=false"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestInsecureClearsCA(t *testing.T) {
    clusterInfoWithInsecure := clientcmdapi.NewCluster()
    clusterInfoWithInsecure.InsecureSkipTLSVerify = true

    clusterInfoWithCA := clientcmdapi.NewCluster()
    clusterInfoWithCA.CertificateAuthority = "cafile"
    clusterInfoWithCA.CertificateAuthorityData = []byte("cadata")

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clusterInfoWithCA

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["another-cluster"] = clusterInfoWithInsecure

    test := configCommandTest{
        args:           []string{"set-cluster", "another-cluster", "--" + clientcmd.FlagInsecure + "=true"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestCADataClearsCA(t *testing.T) {
    fakeCAFile, _ := ioutil.TempFile(os.TempDir(), "")
    defer os.Remove(fakeCAFile.Name())
    fakeData := []byte("cadata")
    ioutil.WriteFile(fakeCAFile.Name(), fakeData, 0600)

    clusterInfoWithCAData := clientcmdapi.NewCluster()
    clusterInfoWithCAData.CertificateAuthorityData = fakeData

    clusterInfoWithCA := clientcmdapi.NewCluster()
    clusterInfoWithCA.CertificateAuthority = "cafile"

    startingConfig := newRedFederalCowHammerConfig()
    startingConfig.Clusters["another-cluster"] = clusterInfoWithCA

    expectedConfig := newRedFederalCowHammerConfig()
    expectedConfig.Clusters["another-cluster"] = clusterInfoWithCAData

    test := configCommandTest{
        args:           []string{"set-cluster", "another-cluster", "--" + clientcmd.FlagCAFile + "=" + fakeCAFile.Name(), "--" + clientcmd.FlagEmbedCerts + "=true"},
        startingConfig: startingConfig,
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestEmbedNoCADisallowed(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    test := configCommandTest{
        args:           []string{"set-cluster", "another-cluster", "--" + clientcmd.FlagEmbedCerts + "=true"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    func() {
        defer func() {
            // Restore cmdutil behavior.
            cmdutil.DefaultBehaviorOnFatal()
        }()

        // Check exit code.
        cmdutil.BehaviorOnFatal(func(e string, code int) {
            if code != 1 {
                t.Errorf("The exit code is %d, expected 1", code)
            }

            expectedOutputs := []string{"--certificate-authority", "embed"}
            test.checkOutput(e, expectedOutputs, t)
        })

        test.run(t)
    }()
}

func TestCAAndInsecureDisallowed(t *testing.T) {
    test := configCommandTest{
        args:           []string{"set-cluster", "another-cluster", "--" + clientcmd.FlagCAFile + "=cafile", "--" + clientcmd.FlagInsecure + "=true"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: newRedFederalCowHammerConfig(),
    }

    func() {
        defer func() {
            // Restore cmdutil behavior.
            cmdutil.DefaultBehaviorOnFatal()
        }()

        // Check exit code.
        cmdutil.BehaviorOnFatal(func(e string, code int) {
            if code != 1 {
                t.Errorf("The exit code is %d, expected 1", code)
            }

            expectedOutputs := []string{"certificate", "insecure"}
            test.checkOutput(e, expectedOutputs, t)
        })

        test.run(t)
    }()
}

func TestMergeExistingAuth(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    authInfo := expectedConfig.AuthInfos["red-user"]
    authInfo.ClientKey = "/key"
    expectedConfig.AuthInfos["red-user"] = authInfo
    test := configCommandTest{
        args:           []string{"set-credentials", "red-user", "--" + clientcmd.FlagKeyFile + "=/key"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestNewEmptyCluster(t *testing.T) {
    expectedConfig := *clientcmdapi.NewConfig()
    expectedConfig.Clusters["new-cluster"] = clientcmdapi.NewCluster()
    test := configCommandTest{
        args:           []string{"set-cluster", "new-cluster"},
        startingConfig: *clientcmdapi.NewConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestAdditionalCluster(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    cluster := clientcmdapi.NewCluster()
    cluster.CertificateAuthority = "/ca-location"
    cluster.InsecureSkipTLSVerify = false
    cluster.Server = "serverlocation"
    expectedConfig.Clusters["different-cluster"] = cluster
    test := configCommandTest{
        args:           []string{"set-cluster", "different-cluster", "--" + clientcmd.FlagAPIServer + "=serverlocation", "--" + clientcmd.FlagInsecure + "=false", "--" + clientcmd.FlagCAFile + "=/ca-location"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestOverwriteExistingCluster(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    cluster := clientcmdapi.NewCluster()
    cluster.Server = "serverlocation"
    expectedConfig.Clusters["cow-cluster"] = cluster

    test := configCommandTest{
        args:           []string{"set-cluster", "cow-cluster", "--" + clientcmd.FlagAPIServer + "=serverlocation"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestNewEmptyContext(t *testing.T) {
    expectedConfig := *clientcmdapi.NewConfig()
    expectedConfig.Contexts["new-context"] = clientcmdapi.NewContext()
    test := configCommandTest{
        args:           []string{"set-context", "new-context"},
        startingConfig: *clientcmdapi.NewConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestAdditionalContext(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    context := clientcmdapi.NewContext()
    context.Cluster = "some-cluster"
    context.AuthInfo = "some-user"
    context.Namespace = "different-namespace"
    expectedConfig.Contexts["different-context"] = context
    test := configCommandTest{
        args:           []string{"set-context", "different-context", "--" + clientcmd.FlagClusterName + "=some-cluster", "--" + clientcmd.FlagAuthInfoName + "=some-user", "--" + clientcmd.FlagNamespace + "=different-namespace"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestMergeExistingContext(t *testing.T) {
    expectedConfig := newRedFederalCowHammerConfig()
    context := expectedConfig.Contexts["federal-context"]
    context.Namespace = "hammer"
    expectedConfig.Contexts["federal-context"] = context

    test := configCommandTest{
        args:           []string{"set-context", "federal-context", "--" + clientcmd.FlagNamespace + "=hammer"},
        startingConfig: newRedFederalCowHammerConfig(),
        expectedConfig: expectedConfig,
    }

    test.run(t)
}

func TestToBool(t *testing.T) {
    type test struct {
        in  string
        out bool
        err string
    }

    tests := []test{
        {"", false, ""},
        {"true", true, ""},
        {"on", false, `strconv.ParseBool: parsing "on": invalid syntax`},
    }

    for _, curr := range tests {
        b, err := toBool(curr.in)
        if (len(curr.err) != 0) && err == nil {
            t.Errorf("Expected error: %v, but got nil", curr.err)
        }
        if (len(curr.err) == 0) && err != nil {
            t.Errorf("Unexpected error: %v", err)
        }
        if (err != nil) && (err.Error() != curr.err) {
            t.Errorf("Expected %v, got %v", curr.err, err)

        }
        if b != curr.out {
            t.Errorf("Expected %v, got %v", curr.out, b)
        }
    }

}

func testConfigCommand(args []string, startingConfig clientcmdapi.Config, t *testing.T) (string, clientcmdapi.Config) {
    fakeKubeFile, _ := ioutil.TempFile(os.TempDir(), "")
    defer os.Remove(fakeKubeFile.Name())
    err := clientcmd.WriteToFile(startingConfig, fakeKubeFile.Name())
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }

    argsToUse := make([]string, 0, 2+len(args))
    argsToUse = append(argsToUse, "--kubeconfig="+fakeKubeFile.Name())
    argsToUse = append(argsToUse, args...)

    streams, _, buf, _ := genericclioptions.NewTestIOStreams()
    cmd := NewCmdConfig(cmdutil.NewFactory(genericclioptions.NewTestConfigFlags()), clientcmd.NewDefaultPathOptions(), streams)
    // "context" is a global flag, inherited from base kubectl command in the real world
    cmd.PersistentFlags().String("context", "", "The name of the kubeconfig context to use")
    cmd.SetArgs(argsToUse)
    cmd.Execute()

    config := clientcmd.GetConfigFromFileOrDie(fakeKubeFile.Name())
    return buf.String(), *config
}

type configCommandTest struct {
    args            []string
    startingConfig  clientcmdapi.Config
    expectedConfig  clientcmdapi.Config
    expectedOutputs []string
}

func (test configCommandTest) checkOutput(out string, expectedOutputs []string, t *testing.T) {
    for _, expectedOutput := range expectedOutputs {
        if !strings.Contains(out, expectedOutput) {
            t.Errorf("expected '%s' in output, got '%s'", expectedOutput, out)
        }
    }
}

func (test configCommandTest) run(t *testing.T) string {
    out, actualConfig := testConfigCommand(test.args, test.startingConfig, t)

    testSetNilMapsToEmpties(reflect.ValueOf(&test.expectedConfig))
    testSetNilMapsToEmpties(reflect.ValueOf(&actualConfig))
    testClearLocationOfOrigin(&actualConfig)

    if !apiequality.Semantic.DeepEqual(test.expectedConfig, actualConfig) {
        t.Errorf("diff: %v", diff.ObjectDiff(test.expectedConfig, actualConfig))
        t.Errorf("expected: %#v\n actual:   %#v", test.expectedConfig, actualConfig)
    }

    test.checkOutput(out, test.expectedOutputs, t)

    return out
}
func testClearLocationOfOrigin(config *clientcmdapi.Config) {
    for key, obj := range config.AuthInfos {
        obj.LocationOfOrigin = ""
        config.AuthInfos[key] = obj
    }
    for key, obj := range config.Clusters {
        obj.LocationOfOrigin = ""
        config.Clusters[key] = obj
    }
    for key, obj := range config.Contexts {
        obj.LocationOfOrigin = ""
        config.Contexts[key] = obj
    }
}
func testSetNilMapsToEmpties(curr reflect.Value) {
    actualCurrValue := curr
    if curr.Kind() == reflect.Ptr {
        actualCurrValue = curr.Elem()
    }

    switch actualCurrValue.Kind() {
    case reflect.Map:
        for _, mapKey := range actualCurrValue.MapKeys() {
            currMapValue := actualCurrValue.MapIndex(mapKey)
            testSetNilMapsToEmpties(currMapValue)
        }

    case reflect.Struct:
        for fieldIndex := 0; fieldIndex < actualCurrValue.NumField(); fieldIndex++ {
            currFieldValue := actualCurrValue.Field(fieldIndex)

            if currFieldValue.Kind() == reflect.Map && currFieldValue.IsNil() {
                newValue := reflect.MakeMap(currFieldValue.Type())
                currFieldValue.Set(newValue)
            } else {
                testSetNilMapsToEmpties(currFieldValue.Addr())
            }
        }

    }

}

Index

Examples

Package Files

config.go create_authinfo.go create_cluster.go create_context.go current_context.go delete_cluster.go delete_context.go delete_user.go get_clusters.go get_contexts.go get_users.go navigation_step_parser.go rename_context.go set.go unset.go use_context.go view.go

func NewCmdConfig Uses

func NewCmdConfig(f cmdutil.Factory, pathOptions *clientcmd.PathOptions, streams genericclioptions.IOStreams) *cobra.Command

NewCmdConfig creates a command object for the "config" action, and adds all child commands to it.

func NewCmdConfigCurrentContext Uses

func NewCmdConfigCurrentContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigCurrentContext returns a Command instance for 'config current-context' sub command

func NewCmdConfigDeleteCluster Uses

func NewCmdConfigDeleteCluster(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigDeleteCluster returns a Command instance for 'config delete-cluster' sub command

func NewCmdConfigDeleteContext Uses

func NewCmdConfigDeleteContext(out, errOut io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigDeleteContext returns a Command instance for 'config delete-context' sub command

func NewCmdConfigDeleteUser Uses

func NewCmdConfigDeleteUser(streams genericclioptions.IOStreams, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigDeleteUser returns a Command instance for 'config delete-user' sub command

func NewCmdConfigGetClusters Uses

func NewCmdConfigGetClusters(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigGetClusters creates a command object for the "get-clusters" action, which lists all clusters defined in the kubeconfig.

func NewCmdConfigGetContexts Uses

func NewCmdConfigGetContexts(streams genericclioptions.IOStreams, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigGetContexts creates a command object for the "get-contexts" action, which retrieves one or more contexts from a kubeconfig.

func NewCmdConfigGetUsers Uses

func NewCmdConfigGetUsers(streams genericclioptions.IOStreams, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigGetUsers creates a command object for the "get-users" action, which lists all users defined in the kubeconfig.

func NewCmdConfigRenameContext Uses

func NewCmdConfigRenameContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigRenameContext creates a command object for the "rename-context" action

func NewCmdConfigSet Uses

func NewCmdConfigSet(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigSet returns a Command instance for 'config set' sub command

func NewCmdConfigSetAuthInfo Uses

func NewCmdConfigSetAuthInfo(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigSetAuthInfo returns an Command option instance for 'config set-credentials' sub command

func NewCmdConfigSetCluster Uses

func NewCmdConfigSetCluster(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigSetCluster returns a Command instance for 'config set-cluster' sub command

func NewCmdConfigSetContext Uses

func NewCmdConfigSetContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigSetContext returns a Command instance for 'config set-context' sub command

func NewCmdConfigUnset Uses

func NewCmdConfigUnset(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigUnset returns a Command instance for 'config unset' sub command

func NewCmdConfigUseContext Uses

func NewCmdConfigUseContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigUseContext returns a Command instance for 'config use-context' sub command

func NewCmdConfigView Uses

func NewCmdConfigView(f cmdutil.Factory, streams genericclioptions.IOStreams, ConfigAccess clientcmd.ConfigAccess) *cobra.Command

NewCmdConfigView returns a Command instance for 'config view' sub command

func RunCurrentContext Uses

func RunCurrentContext(out io.Writer, options *CurrentContextOptions) error

RunCurrentContext performs the execution of 'config current-context' sub command

type CurrentContextOptions Uses

type CurrentContextOptions struct {
    ConfigAccess clientcmd.ConfigAccess
}

CurrentContextOptions holds the command-line options for 'config current-context' sub command

type DeleteUserOptions Uses

type DeleteUserOptions struct {
    genericclioptions.IOStreams
    // contains filtered or unexported fields
}

DeleteUserOptions holds the data needed to run the command

func NewDeleteUserOptions Uses

func NewDeleteUserOptions(ioStreams genericclioptions.IOStreams, configAccess clientcmd.ConfigAccess) *DeleteUserOptions

NewDeleteUserOptions creates the options for the command

func (*DeleteUserOptions) Complete Uses

func (o *DeleteUserOptions) Complete(cmd *cobra.Command, args []string) error

Complete sets up the command to run

func (*DeleteUserOptions) Run Uses

func (o *DeleteUserOptions) Run() error

Run performs the command

func (*DeleteUserOptions) Validate Uses

func (o *DeleteUserOptions) Validate() error

Validate ensures the command has enough info to run

type GetContextsOptions Uses

type GetContextsOptions struct {
    genericclioptions.IOStreams
    // contains filtered or unexported fields
}

GetContextsOptions contains the assignable options from the args.

func (*GetContextsOptions) Complete Uses

func (o *GetContextsOptions) Complete(cmd *cobra.Command, args []string) error

Complete assigns GetContextsOptions from the args.

func (GetContextsOptions) RunGetContexts Uses

func (o GetContextsOptions) RunGetContexts() error

RunGetContexts implements all the necessary functionality for context retrieval.

func (*GetContextsOptions) Validate Uses

func (o *GetContextsOptions) Validate(cmd *cobra.Command) error

Validate ensures the of output format

type GetUsersOptions Uses

type GetUsersOptions struct {
    genericclioptions.IOStreams
    // contains filtered or unexported fields
}

GetUsersOptions holds the data needed to run the command

func NewGetUsersOptions Uses

func NewGetUsersOptions(ioStreams genericclioptions.IOStreams, configAccess clientcmd.ConfigAccess) *GetUsersOptions

NewGetUsersOptions creates the options for the command

func (*GetUsersOptions) Run Uses

func (o *GetUsersOptions) Run() error

Run performs the command

type RenameContextOptions Uses

type RenameContextOptions struct {
    // contains filtered or unexported fields
}

RenameContextOptions contains the options for running the rename-context cli command.

func (*RenameContextOptions) Complete Uses

func (o *RenameContextOptions) Complete(cmd *cobra.Command, args []string, out io.Writer) error

Complete assigns RenameContextOptions from the args.

func (RenameContextOptions) RunRenameContext Uses

func (o RenameContextOptions) RunRenameContext(out io.Writer) error

RunRenameContext performs the execution for 'config rename-context' sub command

func (RenameContextOptions) Validate Uses

func (o RenameContextOptions) Validate() error

Validate makes sure that provided values for command-line options are valid

type ViewOptions Uses

type ViewOptions struct {
    PrintFlags  *genericclioptions.PrintFlags
    PrintObject printers.ResourcePrinterFunc

    ConfigAccess clientcmd.ConfigAccess
    Merge        cliflag.Tristate
    Flatten      bool
    Minify       bool
    RawByteData  bool

    Context      string
    OutputFormat string

    genericclioptions.IOStreams
}

ViewOptions holds the command-line options for 'config view' sub command

func (*ViewOptions) Complete Uses

func (o *ViewOptions) Complete(cmd *cobra.Command, args []string) error

Complete completes the required command-line options

func (ViewOptions) Run Uses

func (o ViewOptions) Run() error

Run performs the execution of 'config view' sub command

func (ViewOptions) Validate Uses

func (o ViewOptions) Validate() error

Validate makes sure that provided values for command-line options are valid

Package config imports 26 packages (graph). Updated 2020-12-10. Refresh now. Tools for package owners.