create_secret_docker_test.go

Documentation: k8s.io/kubectl/pkg/cmd/create

     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 create
    18  
    19  import (
    20  	"testing"
    21  
    22  	corev1 "k8s.io/api/core/v1"
    23  	apiequality "k8s.io/apimachinery/pkg/api/equality"
    24  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    25  )
    26  
    27  func TestCreateSecretDockerRegistry(t *testing.T) {
    28  	username, password, email, server := "test-user", "test-password", "test-user@example.org", "https://index.docker.io/v1/"
    29  	secretData, err := handleDockerCfgJSONContent(username, password, email, server)
    30  	if err != nil {
    31  		t.Errorf("unexpected error: %v", err)
    32  	}
    33  	secretDataNoEmail, err := handleDockerCfgJSONContent(username, password, "", server)
    34  	if err != nil {
    35  		t.Errorf("unexpected error: %v", err)
    36  	}
    37  
    38  	tests := map[string]struct {
    39  		dockerRegistrySecretName string
    40  		dockerUsername           string
    41  		dockerEmail              string
    42  		dockerPassword           string
    43  		dockerServer             string
    44  		appendHash               bool
    45  		expected                 *corev1.Secret
    46  		expectErr                bool
    47  	}{
    48  		"create_secret_docker_registry_with_email": {
    49  			dockerRegistrySecretName: "foo",
    50  			dockerUsername:           username,
    51  			dockerPassword:           password,
    52  			dockerEmail:              email,
    53  			dockerServer:             server,
    54  			expected: &corev1.Secret{
    55  				TypeMeta: metav1.TypeMeta{
    56  					APIVersion: corev1.SchemeGroupVersion.String(),
    57  					Kind:       "Secret",
    58  				},
    59  				ObjectMeta: metav1.ObjectMeta{
    60  					Name: "foo",
    61  				},
    62  				Type: corev1.SecretTypeDockerConfigJson,
    63  				Data: map[string][]byte{
    64  					corev1.DockerConfigJsonKey: secretData,
    65  				},
    66  			},
    67  			expectErr: false,
    68  		},
    69  		"create_secret_docker_registry_with_email_hash": {
    70  			dockerRegistrySecretName: "foo",
    71  			dockerUsername:           username,
    72  			dockerPassword:           password,
    73  			dockerEmail:              email,
    74  			dockerServer:             server,
    75  			appendHash:               true,
    76  			expected: &corev1.Secret{
    77  				TypeMeta: metav1.TypeMeta{
    78  					APIVersion: corev1.SchemeGroupVersion.String(),
    79  					Kind:       "Secret",
    80  				},
    81  				ObjectMeta: metav1.ObjectMeta{
    82  					Name: "foo-548cm7fgdh",
    83  				},
    84  				Type: corev1.SecretTypeDockerConfigJson,
    85  				Data: map[string][]byte{
    86  					corev1.DockerConfigJsonKey: secretData,
    87  				},
    88  			},
    89  			expectErr: false,
    90  		},
    91  		"create_secret_docker_registry_without_email": {
    92  			dockerRegistrySecretName: "foo",
    93  			dockerUsername:           username,
    94  			dockerPassword:           password,
    95  			dockerEmail:              "",
    96  			dockerServer:             server,
    97  			expected: &corev1.Secret{
    98  				TypeMeta: metav1.TypeMeta{
    99  					APIVersion: corev1.SchemeGroupVersion.String(),
   100  					Kind:       "Secret",
   101  				},
   102  				ObjectMeta: metav1.ObjectMeta{
   103  					Name: "foo",
   104  				},
   105  				Type: corev1.SecretTypeDockerConfigJson,
   106  				Data: map[string][]byte{
   107  					corev1.DockerConfigJsonKey: secretDataNoEmail,
   108  				},
   109  			},
   110  			expectErr: false,
   111  		},
   112  		"create_secret_docker_registry_without_email_hash": {
   113  			dockerRegistrySecretName: "foo",
   114  			dockerUsername:           username,
   115  			dockerPassword:           password,
   116  			dockerEmail:              "",
   117  			dockerServer:             server,
   118  			appendHash:               true,
   119  			expected: &corev1.Secret{
   120  				TypeMeta: metav1.TypeMeta{
   121  					APIVersion: corev1.SchemeGroupVersion.String(),
   122  					Kind:       "Secret",
   123  				},
   124  				ObjectMeta: metav1.ObjectMeta{
   125  					Name: "foo-bff5bt4f92",
   126  				},
   127  				Type: corev1.SecretTypeDockerConfigJson,
   128  				Data: map[string][]byte{
   129  					corev1.DockerConfigJsonKey: secretDataNoEmail,
   130  				},
   131  			},
   132  			expectErr: false,
   133  		},
   134  		"create_invalid_secret_docker_registry_without_username": {
   135  			dockerRegistrySecretName: "foo",
   136  			dockerPassword:           password,
   137  			dockerEmail:              "",
   138  			dockerServer:             server,
   139  			expectErr:                true,
   140  		},
   141  		"create_invalid_secret_docker_registry_without_password": {
   142  			dockerRegistrySecretName: "foo",
   143  			dockerUsername:           username,
   144  			dockerEmail:              "",
   145  			dockerServer:             server,
   146  			expectErr:                true,
   147  		},
   148  		"create_invalid_secret_docker_registry_without_server": {
   149  			dockerRegistrySecretName: "foo",
   150  			dockerUsername:           username,
   151  			dockerPassword:           password,
   152  			dockerEmail:              "",
   153  			expectErr:                true,
   154  		},
   155  	}
   156  
   157  	// Run all the tests
   158  	for name, test := range tests {
   159  		t.Run(name, func(t *testing.T) {
   160  			var secretDockerRegistry *corev1.Secret = nil
   161  			secretDockerRegistryOptions := CreateSecretDockerRegistryOptions{
   162  				Name:       test.dockerRegistrySecretName,
   163  				Username:   test.dockerUsername,
   164  				Email:      test.dockerEmail,
   165  				Password:   test.dockerPassword,
   166  				Server:     test.dockerServer,
   167  				AppendHash: test.appendHash,
   168  			}
   169  			err := secretDockerRegistryOptions.Validate()
   170  			if err == nil {
   171  				secretDockerRegistry, err = secretDockerRegistryOptions.createSecretDockerRegistry()
   172  			}
   173  
   174  			if !test.expectErr && err != nil {
   175  				t.Errorf("test %s, unexpected error: %v", name, err)
   176  			}
   177  			if test.expectErr && err == nil {
   178  				t.Errorf("test %s was expecting an error but no error occurred", name)
   179  			}
   180  			if !apiequality.Semantic.DeepEqual(secretDockerRegistry, test.expected) {
   181  				t.Errorf("test %s\n expected:\n%#v\ngot:\n%#v", name, test.expected, secretDockerRegistry)
   182  			}
   183  		})
   184  	}
   185  }
   186
View as plain text