github.com/argoproj/argo-cd/v3@v3.2.1/util/util_test.go (about)

     1  package util_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  	corev1 "k8s.io/api/core/v1"
    10  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    11  
    12  	"github.com/argoproj/argo-cd/v3/util"
    13  	"github.com/argoproj/argo-cd/v3/util/webhook"
    14  )
    15  
    16  func TestMakeSignature(t *testing.T) {
    17  	for size := 1; size <= 64; size++ {
    18  		s, err := util.MakeSignature(size)
    19  		require.NoError(t, err, "Could not generate signature of size %d: %v", size, err)
    20  		t.Logf("Generated token: %v", s)
    21  	}
    22  }
    23  
    24  func TestParseRevision(t *testing.T) {
    25  	type args struct {
    26  		ref string
    27  	}
    28  	tests := []struct {
    29  		name string
    30  		args args
    31  		want string
    32  	}{
    33  		{name: "gitflow", args: args{ref: "refs/heads/fix/appset-webhook"}, want: "fix/appset-webhook"},
    34  		{name: "tag", args: args{ref: "refs/tags/v3.14.1"}, want: "v3.14.1"},
    35  		{name: "env-branch", args: args{ref: "refs/heads/env/dev"}, want: "env/dev"},
    36  		{name: "main", args: args{ref: "refs/heads/main"}, want: "main"},
    37  	}
    38  	for _, tt := range tests {
    39  		t.Run(tt.name, func(t *testing.T) {
    40  			assert.Equalf(t, tt.want, webhook.ParseRevision(tt.args.ref), "parseRevision(%v)", tt.args.ref)
    41  		})
    42  	}
    43  }
    44  
    45  func TestSliceCopy(t *testing.T) {
    46  	type args struct {
    47  		secrets []*corev1.Secret
    48  	}
    49  	tests := []struct {
    50  		name string
    51  		args args
    52  		want []*corev1.Secret
    53  	}{
    54  		{name: "nil", args: args{secrets: nil}, want: []*corev1.Secret{}},
    55  		{
    56  			name: "Three", args: args{secrets: []*corev1.Secret{
    57  				{ObjectMeta: metav1.ObjectMeta{Name: "one"}},
    58  				{ObjectMeta: metav1.ObjectMeta{Name: "two"}},
    59  				{ObjectMeta: metav1.ObjectMeta{Name: "three"}},
    60  			}},
    61  			want: []*corev1.Secret{
    62  				{ObjectMeta: metav1.ObjectMeta{Name: "one"}},
    63  				{ObjectMeta: metav1.ObjectMeta{Name: "two"}},
    64  				{ObjectMeta: metav1.ObjectMeta{Name: "three"}},
    65  			},
    66  		},
    67  		{
    68  			name: "One", args: args{secrets: []*corev1.Secret{{ObjectMeta: metav1.ObjectMeta{Name: "one"}}}},
    69  			want: []*corev1.Secret{{ObjectMeta: metav1.ObjectMeta{Name: "one"}}},
    70  		},
    71  		{name: "Zero", args: args{secrets: []*corev1.Secret{}}, want: []*corev1.Secret{}},
    72  	}
    73  	for _, tt := range tests {
    74  		t.Run(tt.name, func(t *testing.T) {
    75  			secretsCopy := util.SliceCopy(tt.args.secrets)
    76  			assert.Equalf(t, tt.want, secretsCopy, "SliceCopy(%v)", tt.args.secrets)
    77  			for i := range tt.args.secrets {
    78  				assert.NotSame(t, secretsCopy[i], tt.args.secrets[i])
    79  			}
    80  		})
    81  	}
    82  }
    83  
    84  // TestGenerateCacheKey tests the GenerateCacheKey function
    85  func TestGenerateCacheKey(t *testing.T) {
    86  	// Define test cases
    87  	testCases := []struct {
    88  		format    string
    89  		args      []any
    90  		expected  string
    91  		shouldErr bool
    92  	}{
    93  		{
    94  			format:    "Hello %s",
    95  			args:      []any{"World"},
    96  			expected:  "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e",
    97  			shouldErr: false,
    98  		},
    99  		{
   100  			format:    "",
   101  			args:      []any{},
   102  			expected:  "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
   103  			shouldErr: false,
   104  		},
   105  		{
   106  			format:    "Number: %d",
   107  			args:      []any{123},
   108  			expected:  "665fb090bf37fa3cbba9b92b9f82e6fa4bb851bad4c0a0a6edfb0aefa542150b",
   109  			shouldErr: false,
   110  		},
   111  		// Add more test cases as needed
   112  	}
   113  
   114  	for _, tc := range testCases {
   115  		t.Run(fmt.Sprintf("format=%s args=%v", tc.format, tc.args), func(t *testing.T) {
   116  			key, err := util.GenerateCacheKey(tc.format, tc.args...)
   117  			if tc.shouldErr {
   118  				require.Errorf(t, err, "expected error but got none")
   119  				return
   120  			}
   121  			require.NoErrorf(t, err, "unexpected error: %v", err)
   122  			require.Equalf(t, tc.expected, key, "expected %s but got %s", tc.expected, key)
   123  		})
   124  	}
   125  }