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

     1  package commands
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/splunk/qbec/internal/model"
     7  	"github.com/splunk/qbec/internal/remote"
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  /*
    13     Copyright 2019 Splunk Inc.
    14  
    15     Licensed under the Apache License, Version 2.0 (the "License");
    16     you may not use this file except in compliance with the License.
    17     You may obtain a copy of the License at
    18  
    19         http://www.apache.org/licenses/LICENSE-2.0
    20  
    21     Unless required by applicable law or agreed to in writing, software
    22     distributed under the License is distributed on an "AS IS" BASIS,
    23     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    24     See the License for the specific language governing permissions and
    25     limitations under the License.
    26  */
    27  
    28  func TestDeleteRemote(t *testing.T) {
    29  	s := newScaffold(t)
    30  	defer s.reset()
    31  	d := &dg{cmValue: "baz", secretValue: "baz"}
    32  	s.client.getFunc = d.get
    33  	s.client.listFunc = stdLister
    34  	s.client.deleteFunc = func(obj model.K8sMeta, dryRun bool) (*remote.SyncResult, error) {
    35  		return &remote.SyncResult{Type: remote.SyncDeleted}, nil
    36  	}
    37  	err := s.executeCommand("delete", "dev")
    38  	require.Nil(t, err)
    39  	stats := s.outputStats()
    40  	a := assert.New(t)
    41  	a.EqualValues([]interface{}{"Deployment:bar-system:svc2-previous-deploy", "Deployment:bar-system:svc2-deploy"}, stats["deleted"])
    42  }
    43  
    44  func TestDeleteRemoteComponentFilter(t *testing.T) {
    45  	s := newScaffold(t)
    46  	defer s.reset()
    47  	d := &dg{cmValue: "baz", secretValue: "baz"}
    48  	s.client.getFunc = d.get
    49  	s.client.listFunc = stdLister
    50  	s.client.deleteFunc = func(obj model.K8sMeta, dryRun bool) (*remote.SyncResult, error) {
    51  		return &remote.SyncResult{Type: remote.SyncDeleted}, nil
    52  	}
    53  	err := s.executeCommand("delete", "dev", "-c", "service2")
    54  	require.Nil(t, err)
    55  	stats := s.outputStats()
    56  	a := assert.New(t)
    57  	a.EqualValues([]interface{}{"Deployment:bar-system:svc2-previous-deploy"}, stats["deleted"])
    58  }
    59  
    60  func TestDeleteLocal(t *testing.T) {
    61  	s := newScaffold(t)
    62  	defer s.reset()
    63  	d := &dg{cmValue: "baz", secretValue: "baz"}
    64  	s.client.getFunc = d.get
    65  	s.client.deleteFunc = func(obj model.K8sMeta, dryRun bool) (*remote.SyncResult, error) {
    66  		return &remote.SyncResult{Type: remote.SyncDeleted}, nil
    67  	}
    68  	err := s.executeCommand("delete", "dev", "--local", "-C", "cluster-objects")
    69  	require.Nil(t, err)
    70  	stats := s.outputStats()
    71  	a := assert.New(t)
    72  	a.EqualValues([]interface{}{"Deployment:bar-system:svc2-deploy", "Secret:bar-system:svc2-secret", "ConfigMap:bar-system:svc2-cm"}, stats["deleted"])
    73  }
    74  
    75  func TestDeleteNegative(t *testing.T) {
    76  	tests := []struct {
    77  		name     string
    78  		args     []string
    79  		asserter func(s *scaffold, err error)
    80  	}{
    81  		{
    82  			name: "no env",
    83  			args: []string{"delete"},
    84  			asserter: func(s *scaffold, err error) {
    85  				a := assert.New(s.t)
    86  				a.True(isUsageError(err))
    87  				a.Equal("exactly one environment required", err.Error())
    88  			},
    89  		},
    90  		{
    91  			name: "2 envs",
    92  			args: []string{"delete", "dev", "prod"},
    93  			asserter: func(s *scaffold, err error) {
    94  				a := assert.New(s.t)
    95  				a.True(isUsageError(err))
    96  				a.Equal("exactly one environment required", err.Error())
    97  			},
    98  		},
    99  		{
   100  			name: "bad env",
   101  			args: []string{"delete", "foo"},
   102  			asserter: func(s *scaffold, err error) {
   103  				a := assert.New(s.t)
   104  				a.False(isUsageError(err))
   105  				a.Equal("invalid environment \"foo\"", err.Error())
   106  			},
   107  		},
   108  		{
   109  			name: "baseline env",
   110  			args: []string{"delete", "_"},
   111  			asserter: func(s *scaffold, err error) {
   112  				a := assert.New(s.t)
   113  				a.True(isUsageError(err))
   114  				a.Equal("cannot delete baseline environment, use a real environment", err.Error())
   115  			},
   116  		},
   117  		{
   118  			name: "c and C",
   119  			args: []string{"delete", "dev", "-c", "cluster-objects", "-C", "service2"},
   120  			asserter: func(s *scaffold, err error) {
   121  				a := assert.New(s.t)
   122  				a.True(isUsageError(err))
   123  				a.Equal(`cannot include as well as exclude components, specify one or the other`, err.Error())
   124  			},
   125  		},
   126  		{
   127  			name: "k and K",
   128  			args: []string{"delete", "dev", "-k", "namespace", "-K", "secret"},
   129  			asserter: func(s *scaffold, err error) {
   130  				a := assert.New(s.t)
   131  				a.True(isUsageError(err))
   132  				a.Equal(`cannot include as well as exclude kinds, specify one or the other`, err.Error())
   133  			},
   134  		},
   135  	}
   136  	for _, test := range tests {
   137  		t.Run(test.name, func(t *testing.T) {
   138  			s := newScaffold(t)
   139  			defer s.reset()
   140  			err := s.executeCommand(test.args...)
   141  			require.NotNil(t, err)
   142  			test.asserter(s, err)
   143  		})
   144  	}
   145  
   146  }