1
16
17 package images
18
19 import (
20 "fmt"
21 "testing"
22
23 "github.com/stretchr/testify/assert"
24 kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
25 kubeadmapiv1beta3 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
26 "k8s.io/kubernetes/cmd/kubeadm/app/constants"
27 )
28
29 const (
30 testversion = "v10.1.2-alpha.1.100+0123456789abcdef"
31 expected = "v10.1.2-alpha.1.100_0123456789abcdef"
32 gcrPrefix = "registry.k8s.io"
33 )
34
35 func TestGetGenericImage(t *testing.T) {
36 const (
37 prefix = "foo"
38 image = "bar"
39 tag = "baz"
40 )
41 expected := fmt.Sprintf("%s/%s:%s", prefix, image, tag)
42 actual := GetGenericImage(prefix, image, tag)
43 if actual != expected {
44 t.Errorf("failed GetGenericImage:\n\texpected: %s\n\t actual: %s", expected, actual)
45 }
46 }
47
48 func TestGetKubernetesImage(t *testing.T) {
49 var tests = []struct {
50 image string
51 expected string
52 cfg *kubeadmapi.ClusterConfiguration
53 }{
54 {
55 image: constants.KubeAPIServer,
56 expected: GetGenericImage(gcrPrefix, "kube-apiserver", expected),
57 cfg: &kubeadmapi.ClusterConfiguration{
58 ImageRepository: gcrPrefix,
59 KubernetesVersion: testversion,
60 },
61 },
62 {
63 image: constants.KubeControllerManager,
64 expected: GetGenericImage(gcrPrefix, "kube-controller-manager", expected),
65 cfg: &kubeadmapi.ClusterConfiguration{
66 ImageRepository: gcrPrefix,
67 KubernetesVersion: testversion,
68 },
69 },
70 {
71 image: constants.KubeScheduler,
72 expected: GetGenericImage(gcrPrefix, "kube-scheduler", expected),
73 cfg: &kubeadmapi.ClusterConfiguration{
74 ImageRepository: gcrPrefix,
75 KubernetesVersion: testversion,
76 },
77 },
78 {
79 image: constants.KubeProxy,
80 expected: GetGenericImage(gcrPrefix, "kube-proxy", expected),
81 cfg: &kubeadmapi.ClusterConfiguration{
82 ImageRepository: gcrPrefix,
83 KubernetesVersion: testversion,
84 },
85 },
86 }
87 for _, rt := range tests {
88 actual := GetKubernetesImage(rt.image, rt.cfg)
89 if actual != rt.expected {
90 t.Errorf(
91 "failed GetKubernetesImage:\n\texpected: %s\n\t actual: %s",
92 rt.expected,
93 actual,
94 )
95 }
96 }
97 }
98
99 func TestGetEtcdImage(t *testing.T) {
100 testEtcdVer, _, _ := constants.EtcdSupportedVersion(constants.SupportedEtcdVersion, testversion)
101 var tests = []struct {
102 expected string
103 cfg *kubeadmapi.ClusterConfiguration
104 }{
105 {
106 cfg: &kubeadmapi.ClusterConfiguration{
107 ImageRepository: "real.repo",
108 KubernetesVersion: testversion,
109 Etcd: kubeadmapi.Etcd{
110 Local: &kubeadmapi.LocalEtcd{},
111 },
112 },
113 expected: "real.repo/etcd:" + testEtcdVer.String(),
114 },
115 {
116 cfg: &kubeadmapi.ClusterConfiguration{
117 ImageRepository: "real.repo",
118 KubernetesVersion: testversion,
119 Etcd: kubeadmapi.Etcd{
120 Local: &kubeadmapi.LocalEtcd{
121 ImageMeta: kubeadmapi.ImageMeta{
122 ImageTag: "override",
123 },
124 },
125 },
126 },
127 expected: "real.repo/etcd:override",
128 },
129 {
130 cfg: &kubeadmapi.ClusterConfiguration{
131 ImageRepository: "real.repo",
132 KubernetesVersion: testversion,
133 Etcd: kubeadmapi.Etcd{
134 Local: &kubeadmapi.LocalEtcd{
135 ImageMeta: kubeadmapi.ImageMeta{
136 ImageRepository: "override",
137 },
138 },
139 },
140 },
141 expected: "override/etcd:" + testEtcdVer.String(),
142 },
143 {
144 expected: GetGenericImage(gcrPrefix, "etcd", constants.DefaultEtcdVersion),
145 cfg: &kubeadmapi.ClusterConfiguration{
146 ImageRepository: gcrPrefix,
147 KubernetesVersion: testversion,
148 },
149 },
150 }
151 for _, rt := range tests {
152 actual := GetEtcdImage(rt.cfg)
153 if actual != rt.expected {
154 t.Errorf(
155 "failed GetEtcdImage:\n\texpected: %s\n\t actual: %s",
156 rt.expected,
157 actual,
158 )
159 }
160 }
161 }
162
163 func TestGetPauseImage(t *testing.T) {
164 testcases := []struct {
165 name string
166 cfg *kubeadmapi.ClusterConfiguration
167 expected string
168 }{
169 {
170 name: "pause image defined",
171 cfg: &kubeadmapi.ClusterConfiguration{
172 ImageRepository: "test.repo",
173 },
174 expected: "test.repo/pause:" + constants.PauseVersion,
175 },
176 }
177 for _, tc := range testcases {
178 t.Run(tc.name, func(t *testing.T) {
179 actual := GetPauseImage(tc.cfg)
180 if actual != tc.expected {
181 t.Fatalf(
182 "failed GetPauseImage:\n\texpected: %s\n\t actual: %s",
183 tc.expected,
184 actual,
185 )
186 }
187 })
188 }
189 }
190
191 func TestGetAllImages(t *testing.T) {
192 testcases := []struct {
193 name string
194 expectedImages []string
195 cfg *kubeadmapi.ClusterConfiguration
196 }{
197 {
198 name: "defined CIImageRepository",
199 cfg: &kubeadmapi.ClusterConfiguration{
200 CIImageRepository: "test.repo",
201 },
202 expectedImages: []string{
203 "test.repo/kube-apiserver:",
204 "test.repo/kube-controller-manager:",
205 "test.repo/kube-scheduler:",
206 "test.repo/kube-proxy:",
207 "/coredns:" + constants.CoreDNSVersion,
208 "/pause:" + constants.PauseVersion,
209 },
210 },
211 {
212 name: "undefined CIImagerRepository should contain the default image prefix",
213 cfg: &kubeadmapi.ClusterConfiguration{
214 ImageRepository: "real.repo",
215 },
216 expectedImages: []string{
217 "real.repo/kube-apiserver:",
218 "real.repo/kube-controller-manager:",
219 "real.repo/kube-scheduler:",
220 "real.repo/kube-proxy:",
221 "real.repo/coredns:" + constants.CoreDNSVersion,
222 "real.repo/pause:" + constants.PauseVersion,
223 },
224 },
225 {
226 name: "test that etcd is returned when it is not external",
227 cfg: &kubeadmapi.ClusterConfiguration{
228 Etcd: kubeadmapi.Etcd{
229 Local: &kubeadmapi.LocalEtcd{},
230 },
231 },
232 expectedImages: []string{
233 "/kube-apiserver:",
234 "/kube-controller-manager:",
235 "/kube-scheduler:",
236 "/kube-proxy:",
237 "/coredns:" + constants.CoreDNSVersion,
238 "/pause:" + constants.PauseVersion,
239 "/etcd:" + constants.DefaultEtcdVersion,
240 },
241 },
242 {
243 name: "CoreDNS and kube-proxy image are returned",
244 cfg: &kubeadmapi.ClusterConfiguration{},
245 expectedImages: []string{
246 "/kube-apiserver:",
247 "/kube-controller-manager:",
248 "/kube-scheduler:",
249 "/kube-proxy:",
250 "/coredns:" + constants.CoreDNSVersion,
251 "/pause:" + constants.PauseVersion,
252 },
253 },
254 {
255 name: "CoreDNS image is skipped",
256 cfg: &kubeadmapi.ClusterConfiguration{
257 DNS: kubeadmapi.DNS{
258 Disabled: true,
259 },
260 },
261 expectedImages: []string{
262 "/kube-apiserver:",
263 "/kube-controller-manager:",
264 "/kube-scheduler:",
265 "/kube-proxy:",
266 "/pause:" + constants.PauseVersion,
267 },
268 },
269 {
270 name: "kube-proxy image is skipped",
271 cfg: &kubeadmapi.ClusterConfiguration{
272 Proxy: kubeadmapi.Proxy{
273 Disabled: true,
274 },
275 },
276 expectedImages: []string{
277 "/kube-apiserver:",
278 "/kube-controller-manager:",
279 "/kube-scheduler:",
280 "/coredns:" + constants.CoreDNSVersion,
281 "/pause:" + constants.PauseVersion,
282 },
283 },
284 {
285 name: "setting addons Disabled to false has no effect",
286 cfg: &kubeadmapi.ClusterConfiguration{
287 DNS: kubeadmapi.DNS{
288 Disabled: false,
289 },
290 Proxy: kubeadmapi.Proxy{
291 Disabled: false,
292 },
293 },
294 expectedImages: []string{
295 "/kube-apiserver:",
296 "/kube-controller-manager:",
297 "/kube-scheduler:",
298 "/kube-proxy:",
299 "/coredns:" + constants.CoreDNSVersion,
300 "/pause:" + constants.PauseVersion,
301 },
302 },
303 }
304 for _, tc := range testcases {
305 t.Run(tc.name, func(t *testing.T) {
306 imgs := GetControlPlaneImages(tc.cfg)
307 assert.Equal(t, tc.expectedImages, imgs)
308 })
309 }
310 }
311
312 func TestGetDNSImage(t *testing.T) {
313 var tests = []struct {
314 expected string
315 cfg *kubeadmapi.ClusterConfiguration
316 }{
317 {
318 expected: "foo.io/coredns:v1.11.1",
319 cfg: &kubeadmapi.ClusterConfiguration{
320 ImageRepository: "foo.io",
321 DNS: kubeadmapi.DNS{},
322 },
323 },
324 {
325 expected: kubeadmapiv1beta3.DefaultImageRepository + "/coredns/coredns:v1.11.1",
326 cfg: &kubeadmapi.ClusterConfiguration{
327 ImageRepository: kubeadmapiv1beta3.DefaultImageRepository,
328 DNS: kubeadmapi.DNS{},
329 },
330 },
331 {
332 expected: "foo.io/coredns/coredns:v1.11.1",
333 cfg: &kubeadmapi.ClusterConfiguration{
334 ImageRepository: "foo.io",
335 DNS: kubeadmapi.DNS{
336 ImageMeta: kubeadmapi.ImageMeta{
337 ImageRepository: "foo.io/coredns",
338 },
339 },
340 },
341 },
342 {
343 expected: "foo.io/coredns/coredns:v1.11.1",
344 cfg: &kubeadmapi.ClusterConfiguration{
345 ImageRepository: "foo.io/coredns",
346 DNS: kubeadmapi.DNS{
347 ImageMeta: kubeadmapi.ImageMeta{
348 ImageTag: "v1.11.1",
349 },
350 },
351 },
352 },
353 }
354
355 for _, test := range tests {
356 actual := GetDNSImage(test.cfg)
357 if actual != test.expected {
358 t.Errorf(
359 "failed to GetDNSImage:\n\texpected: %s\n\t actual: %s",
360 test.expected,
361 actual,
362 )
363 }
364 }
365 }
366
View as plain text