flags_test.go

Documentation: k8s.io/component-base/cli/flag

     1  /*
     2  Copyright 2021 The Kubernetes Authors.
     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 flag
    18  
    19  import (
    20  	"bytes"
    21  	"testing"
    22  
    23  	"github.com/go-logr/logr"
    24  	"github.com/spf13/pflag"
    25  	"github.com/stretchr/testify/assert"
    26  	"k8s.io/klog/v2"
    27  )
    28  
    29  type FakeLogger struct {
    30  	logr.Logger
    31  	infoBuffer  bytes.Buffer
    32  	errorBuffer bytes.Buffer
    33  }
    34  
    35  func (logger *FakeLogger) Init(info logr.RuntimeInfo) {}
    36  func (logger *FakeLogger) Enabled(lvl int) bool       { return true }
    37  func (logger *FakeLogger) Info(lvl int, msg string, keysAndValues ...interface{}) {
    38  	logger.infoBuffer.WriteString(msg)
    39  }
    40  func (logger *FakeLogger) Error(err error, msg string, keysAndValues ...interface{}) {
    41  	logger.errorBuffer.WriteString(msg)
    42  }
    43  func (logger *FakeLogger) WithValues(keysAndValues ...interface{}) logr.LogSink { return logger }
    44  func (logger *FakeLogger) WithName(name string) logr.LogSink                    { return logger }
    45  
    46  var _ logr.LogSink = &FakeLogger{}
    47  
    48  func TestWordSepNormalizeFunc(t *testing.T) {
    49  	cases := []struct {
    50  		flagName         string
    51  		expectedFlagName string
    52  	}{
    53  		{
    54  			flagName:         "foo",
    55  			expectedFlagName: "foo",
    56  		},
    57  		{
    58  			flagName:         "foo-bar",
    59  			expectedFlagName: "foo-bar",
    60  		},
    61  		{
    62  			flagName:         "foo_bar",
    63  			expectedFlagName: "foo-bar",
    64  		},
    65  	}
    66  	for _, tc := range cases {
    67  		t.Run(tc.flagName, func(t *testing.T) {
    68  			fakeLogger := &FakeLogger{}
    69  			klog.SetLogger(logr.New(fakeLogger))
    70  			result := WordSepNormalizeFunc(nil, tc.flagName)
    71  			assert.Equal(t, pflag.NormalizedName(tc.expectedFlagName), result)
    72  			assert.Equal(t, "", fakeLogger.infoBuffer.String())
    73  			assert.Equal(t, "", fakeLogger.errorBuffer.String())
    74  		})
    75  	}
    76  }
    77  
    78  func TestWarnWordSepNormalizeFunc(t *testing.T) {
    79  	cases := []struct {
    80  		flagName         string
    81  		expectedFlagName string
    82  		expectedWarning  string
    83  	}{
    84  		{
    85  			flagName:         "foo",
    86  			expectedFlagName: "foo",
    87  			expectedWarning:  "",
    88  		},
    89  		{
    90  			flagName:         "foo-bar",
    91  			expectedFlagName: "foo-bar",
    92  			expectedWarning:  "",
    93  		},
    94  		{
    95  			flagName:         "foo_bar",
    96  			expectedFlagName: "foo-bar",
    97  			expectedWarning:  "using an underscore in a flag name is not supported. foo_bar has been converted to foo-bar.",
    98  		},
    99  	}
   100  	for _, tc := range cases {
   101  		t.Run(tc.flagName, func(t *testing.T) {
   102  			fakeLogger := &FakeLogger{}
   103  			klog.SetLogger(logr.New(fakeLogger))
   104  			result := WarnWordSepNormalizeFunc(nil, tc.flagName)
   105  			assert.Equal(t, pflag.NormalizedName(tc.expectedFlagName), result)
   106  			assert.Equal(t, tc.expectedWarning, fakeLogger.infoBuffer.String())
   107  			assert.Equal(t, "", fakeLogger.errorBuffer.String())
   108  		})
   109  	}
   110  }
   111
View as plain text