github.com/argoproj/argo-cd/v3@v3.2.1/common/common_test.go (about)

     1  package common
     2  
     3  import (
     4  	"fmt"
     5  	"strconv"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/redis/go-redis/v9"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  	corev1 "k8s.io/api/core/v1"
    13  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    14  	kubefake "k8s.io/client-go/kubernetes/fake"
    15  )
    16  
    17  // Test env var not set for EnvGRPCKeepAliveMin
    18  func Test_GRPCKeepAliveMinNotSet(t *testing.T) {
    19  	grpcKeepAliveMin := GetGRPCKeepAliveEnforcementMinimum()
    20  	grpcKeepAliveExpectedMin := defaultGRPCKeepAliveEnforcementMinimum
    21  	assert.Equal(t, grpcKeepAliveExpectedMin, grpcKeepAliveMin)
    22  
    23  	grpcKeepAliveTime := GetGRPCKeepAliveTime()
    24  	assert.Equal(t, 2*grpcKeepAliveExpectedMin, grpcKeepAliveTime)
    25  }
    26  
    27  // Test valid env var set for EnvGRPCKeepAliveMin
    28  func Test_GRPCKeepAliveMinIsSet(t *testing.T) {
    29  	numSeconds := 15
    30  	t.Setenv(EnvGRPCKeepAliveMin, fmt.Sprintf("%ds", numSeconds))
    31  
    32  	grpcKeepAliveMin := GetGRPCKeepAliveEnforcementMinimum()
    33  	grpcKeepAliveExpectedMin := time.Duration(numSeconds) * time.Second
    34  	assert.Equal(t, grpcKeepAliveExpectedMin, grpcKeepAliveMin)
    35  
    36  	grpcKeepAliveTime := GetGRPCKeepAliveTime()
    37  	assert.Equal(t, 2*grpcKeepAliveExpectedMin, grpcKeepAliveTime)
    38  }
    39  
    40  // Test invalid env var set for EnvGRPCKeepAliveMin
    41  func Test_GRPCKeepAliveMinIncorrectlySet(t *testing.T) {
    42  	numSeconds := 15
    43  	t.Setenv(EnvGRPCKeepAliveMin, strconv.Itoa(numSeconds))
    44  
    45  	grpcKeepAliveMin := GetGRPCKeepAliveEnforcementMinimum()
    46  	grpcKeepAliveExpectedMin := defaultGRPCKeepAliveEnforcementMinimum
    47  	assert.Equal(t, grpcKeepAliveExpectedMin, grpcKeepAliveMin)
    48  
    49  	grpcKeepAliveTime := GetGRPCKeepAliveTime()
    50  	assert.Equal(t, 2*grpcKeepAliveExpectedMin, grpcKeepAliveTime)
    51  }
    52  
    53  func TestSetOptionalRedisPasswordFromKubeConfig(t *testing.T) {
    54  	t.Parallel()
    55  	testCases := []struct {
    56  		name, namespace, expectedPassword, expectedErr string
    57  		secret                                         *corev1.Secret
    58  	}{
    59  		{
    60  			name:             "Secret exists with correct key",
    61  			namespace:        "default",
    62  			expectedPassword: "password123",
    63  			expectedErr:      "",
    64  			secret: &corev1.Secret{
    65  				ObjectMeta: metav1.ObjectMeta{Name: RedisInitialCredentials},
    66  				Data:       map[string][]byte{RedisInitialCredentialsKey: []byte("password123")},
    67  			},
    68  		},
    69  		{
    70  			name:             "Secret does not exist",
    71  			namespace:        "default",
    72  			expectedPassword: "",
    73  			expectedErr:      "failed to get secret default/" + RedisInitialCredentials,
    74  			secret:           nil,
    75  		},
    76  		{
    77  			name:             "Secret exists without correct key",
    78  			namespace:        "default",
    79  			expectedPassword: "",
    80  			expectedErr:      fmt.Sprintf("secret default/%s does not contain key %s", RedisInitialCredentials, RedisInitialCredentialsKey),
    81  			secret: &corev1.Secret{
    82  				ObjectMeta: metav1.ObjectMeta{Name: RedisInitialCredentials},
    83  				Data:       map[string][]byte{},
    84  			},
    85  		},
    86  	}
    87  	for _, tc := range testCases {
    88  		tc := tc
    89  		t.Run(tc.name, func(t *testing.T) {
    90  			t.Parallel()
    91  			var (
    92  				ctx          = t.Context()
    93  				kubeClient   = kubefake.NewClientset()
    94  				redisOptions = &redis.Options{}
    95  			)
    96  			if tc.secret != nil {
    97  				_, err := kubeClient.CoreV1().Secrets(tc.namespace).Create(ctx, tc.secret, metav1.CreateOptions{})
    98  				require.NoErrorf(t, err, "Failed to create secret")
    99  			}
   100  			err := SetOptionalRedisPasswordFromKubeConfig(ctx, kubeClient, tc.namespace, redisOptions)
   101  			if tc.expectedErr != "" {
   102  				require.ErrorContains(t, err, tc.expectedErr)
   103  			} else {
   104  				require.NoError(t, err)
   105  			}
   106  			require.Equal(t, tc.expectedPassword, redisOptions.Password)
   107  		})
   108  	}
   109  }