github.com/splunk/dan1-qbec@v0.7.3/internal/commands/env_test.go (about)

     1  /*
     2     Copyright 2019 Splunk Inc.
     3  
     4     Licensed under the Apache License, Version 2.0 (the "License");
     5     you may not use this file except in compliance with the License.
     6     You may obtain a copy of the License at
     7  
     8         http://www.apache.org/licenses/LICENSE-2.0
     9  
    10     Unless required by applicable law or agreed to in writing, software
    11     distributed under the License is distributed on an "AS IS" BASIS,
    12     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13     See the License for the specific language governing permissions and
    14     limitations under the License.
    15  */
    16  
    17  package commands
    18  
    19  import (
    20  	"regexp"
    21  	"strings"
    22  	"testing"
    23  
    24  	"github.com/stretchr/testify/assert"
    25  	"github.com/stretchr/testify/require"
    26  )
    27  
    28  func TestEnvListBasic(t *testing.T) {
    29  	s := newScaffold(t)
    30  	defer s.reset()
    31  	err := s.executeCommand("env", "list")
    32  	require.Nil(t, err)
    33  	lines := strings.Split(strings.Trim(s.stdout(), "\n"), "\n")
    34  	a := assert.New(t)
    35  	require.Equal(t, 2, len(lines))
    36  	a.Equal("dev", lines[0])
    37  	a.Equal("prod", lines[1])
    38  }
    39  
    40  func TestEnvListYAML(t *testing.T) {
    41  	s := newScaffold(t)
    42  	defer s.reset()
    43  	err := s.executeCommand("env", "list", "-o", "yaml")
    44  	require.Nil(t, err)
    45  	out, err := s.yamlOutput()
    46  	require.Nil(t, err)
    47  	assert.True(t, len(out) > 0)
    48  }
    49  
    50  func TestEnvListJSON(t *testing.T) {
    51  	s := newScaffold(t)
    52  	defer s.reset()
    53  	err := s.executeCommand("env", "list", "-o", "json")
    54  	require.Nil(t, err)
    55  	var data interface{}
    56  	err = s.jsonOutput(&data)
    57  	require.Nil(t, err)
    58  }
    59  
    60  func TestEnvVarsBasic(t *testing.T) {
    61  	s := newScaffold(t)
    62  	defer s.reset()
    63  	err := s.executeCommand("env", "vars", "dev")
    64  	require.Nil(t, err)
    65  	s.assertOutputLineMatch(regexp.MustCompile(`KUBECONFIG='kube.config';`))
    66  	s.assertOutputLineMatch(regexp.MustCompile(`KUBE_CLUSTER='dev.server.com';`))
    67  	s.assertOutputLineMatch(regexp.MustCompile(`KUBE_CONTEXT='foo'`))
    68  	s.assertOutputLineMatch(regexp.MustCompile(`KUBE_NAMESPACE='my-ns';`))
    69  	s.assertOutputLineMatch(regexp.MustCompile(`export KUBECONFIG KUBE_CLUSTER KUBE_CONTEXT KUBE_NAMESPACE KUBECTL_ARGS`))
    70  }
    71  
    72  func TestEnvVarsYAML(t *testing.T) {
    73  	s := newScaffold(t)
    74  	defer s.reset()
    75  	err := s.executeCommand("env", "vars", "dev", "-o", "yaml")
    76  	require.Nil(t, err)
    77  	out, err := s.yamlOutput()
    78  	require.Nil(t, err)
    79  	assert.True(t, len(out) > 0)
    80  }
    81  
    82  func TestEnvVarsJSON(t *testing.T) {
    83  	s := newScaffold(t)
    84  	defer s.reset()
    85  	err := s.executeCommand("env", "vars", "dev", "-o", "json")
    86  	require.Nil(t, err)
    87  	var data interface{}
    88  	err = s.jsonOutput(&data)
    89  	require.Nil(t, err)
    90  }
    91  
    92  func TestEnvNegative(t *testing.T) {
    93  	tests := []struct {
    94  		name     string
    95  		args     []string
    96  		asserter func(s *scaffold, err error)
    97  	}{
    98  		{
    99  			name: "list with env",
   100  			args: []string{"env", "list", "dev"},
   101  			asserter: func(s *scaffold, err error) {
   102  				a := assert.New(s.t)
   103  				a.True(isUsageError(err))
   104  				a.Equal("extra arguments specified", err.Error())
   105  			},
   106  		},
   107  		{
   108  			name: "list bad format",
   109  			args: []string{"env", "list", "-o", "table"},
   110  			asserter: func(s *scaffold, err error) {
   111  				a := assert.New(s.t)
   112  				a.True(isUsageError(err))
   113  				a.Equal(`listEnvironments: unsupported format "table"`, err.Error())
   114  			},
   115  		},
   116  		{
   117  			name: "vars no env",
   118  			args: []string{"env", "vars"},
   119  			asserter: func(s *scaffold, err error) {
   120  				a := assert.New(s.t)
   121  				a.True(isUsageError(err))
   122  				a.Equal(`exactly one environment required`, err.Error())
   123  			},
   124  		},
   125  		{
   126  			name: "vars two envs",
   127  			args: []string{"env", "vars", "dev", "prod"},
   128  			asserter: func(s *scaffold, err error) {
   129  				a := assert.New(s.t)
   130  				a.True(isUsageError(err))
   131  				a.Equal(`exactly one environment required`, err.Error())
   132  			},
   133  		},
   134  		{
   135  			name: "vars bad env",
   136  			args: []string{"env", "vars", "foo"},
   137  			asserter: func(s *scaffold, err error) {
   138  				a := assert.New(s.t)
   139  				a.False(isUsageError(err))
   140  				a.Equal(`invalid environment: "foo"`, err.Error())
   141  			},
   142  		},
   143  		{
   144  			name: "vars bad format",
   145  			args: []string{"env", "vars", "-o", "table", "dev"},
   146  			asserter: func(s *scaffold, err error) {
   147  				a := assert.New(s.t)
   148  				a.True(isUsageError(err))
   149  				a.Equal(`environmentVars: unsupported format "table"`, err.Error())
   150  			},
   151  		},
   152  	}
   153  
   154  	for _, test := range tests {
   155  		t.Run(test.name, func(t *testing.T) {
   156  			s := newScaffold(t)
   157  			defer s.reset()
   158  			err := s.executeCommand(test.args...)
   159  			require.NotNil(t, err)
   160  			test.asserter(s, err)
   161  		})
   162  	}
   163  }