podman

1
//go:build !remote
2

3
package generate
4

5
import (
6
	"testing"
7

8
	"github.com/containers/common/libnetwork/types"
9
	"github.com/stretchr/testify/assert"
10
)
11

12
func TestParsePortMappingWithHostPort(t *testing.T) {
13
	tests := []struct {
14
		name string
15
		arg  []types.PortMapping
16
		arg2 map[uint16][]string
17
		want []types.PortMapping
18
	}{
19
		{
20
			name: "no ports",
21
			arg:  nil,
22
			want: nil,
23
		},
24
		{
25
			name: "one tcp port",
26
			arg: []types.PortMapping{
27
				{
28
					HostPort:      8080,
29
					ContainerPort: 80,
30
					Protocol:      "tcp",
31
				},
32
			},
33
			want: []types.PortMapping{
34
				{
35
					HostPort:      8080,
36
					ContainerPort: 80,
37
					Protocol:      "tcp",
38
					Range:         1,
39
				},
40
			},
41
		},
42
		{
43
			name: "one tcp port no proto",
44
			arg: []types.PortMapping{
45
				{
46
					HostPort:      8080,
47
					ContainerPort: 80,
48
				},
49
			},
50
			want: []types.PortMapping{
51
				{
52
					HostPort:      8080,
53
					ContainerPort: 80,
54
					Protocol:      "tcp",
55
					Range:         1,
56
				},
57
			},
58
		},
59
		{
60
			name: "one udp port",
61
			arg: []types.PortMapping{
62
				{
63
					HostPort:      8080,
64
					ContainerPort: 80,
65
					Protocol:      "udp",
66
				},
67
			},
68
			want: []types.PortMapping{
69
				{
70
					HostPort:      8080,
71
					ContainerPort: 80,
72
					Protocol:      "udp",
73
					Range:         1,
74
				},
75
			},
76
		},
77
		{
78
			name: "one sctp port",
79
			arg: []types.PortMapping{
80
				{
81
					HostPort:      8080,
82
					ContainerPort: 80,
83
					Protocol:      "sctp",
84
				},
85
			},
86
			want: []types.PortMapping{
87
				{
88
					HostPort:      8080,
89
					ContainerPort: 80,
90
					Protocol:      "sctp",
91
					Range:         1,
92
				},
93
			},
94
		},
95
		{
96
			name: "one port two protocols",
97
			arg: []types.PortMapping{
98
				{
99
					HostPort:      8080,
100
					ContainerPort: 80,
101
					Protocol:      "tcp,udp",
102
				},
103
			},
104
			want: []types.PortMapping{
105
				{
106
					HostPort:      8080,
107
					ContainerPort: 80,
108
					Protocol:      "tcp",
109
					Range:         1,
110
				},
111
				{
112
					HostPort:      8080,
113
					ContainerPort: 80,
114
					Protocol:      "udp",
115
					Range:         1,
116
				},
117
			},
118
		},
119
		{
120
			name: "one port three protocols",
121
			arg: []types.PortMapping{
122
				{
123
					HostPort:      8080,
124
					ContainerPort: 80,
125
					Protocol:      "tcp,udp,sctp",
126
				},
127
			},
128
			want: []types.PortMapping{
129
				{
130
					HostPort:      8080,
131
					ContainerPort: 80,
132
					Protocol:      "tcp",
133
					Range:         1,
134
				},
135
				{
136
					HostPort:      8080,
137
					ContainerPort: 80,
138
					Protocol:      "udp",
139
					Range:         1,
140
				},
141
				{
142
					HostPort:      8080,
143
					ContainerPort: 80,
144
					Protocol:      "sctp",
145
					Range:         1,
146
				},
147
			},
148
		},
149
		{
150
			name: "one port with range 1",
151
			arg: []types.PortMapping{
152
				{
153
					HostPort:      8080,
154
					ContainerPort: 80,
155
					Protocol:      "tcp",
156
					Range:         1,
157
				},
158
			},
159
			want: []types.PortMapping{
160
				{
161
					HostPort:      8080,
162
					ContainerPort: 80,
163
					Protocol:      "tcp",
164
					Range:         1,
165
				},
166
			},
167
		},
168
		{
169
			name: "one port with range 5",
170
			arg: []types.PortMapping{
171
				{
172
					HostPort:      8080,
173
					ContainerPort: 80,
174
					Protocol:      "tcp",
175
					Range:         5,
176
				},
177
			},
178
			want: []types.PortMapping{
179
				{
180
					HostPort:      8080,
181
					ContainerPort: 80,
182
					Protocol:      "tcp",
183
					Range:         5,
184
				},
185
			},
186
		},
187
		{
188
			name: "two ports joined",
189
			arg: []types.PortMapping{
190
				{
191
					HostPort:      8080,
192
					ContainerPort: 80,
193
					Protocol:      "tcp",
194
				},
195
				{
196
					HostPort:      8081,
197
					ContainerPort: 81,
198
					Protocol:      "tcp",
199
				},
200
			},
201
			want: []types.PortMapping{
202
				{
203
					HostPort:      8080,
204
					ContainerPort: 80,
205
					Protocol:      "tcp",
206
					Range:         2,
207
				},
208
			},
209
		},
210
		{
211
			name: "two ports joined with range",
212
			arg: []types.PortMapping{
213
				{
214
					HostPort:      8080,
215
					ContainerPort: 80,
216
					Protocol:      "tcp",
217
					Range:         2,
218
				},
219
				{
220
					HostPort:      8081,
221
					ContainerPort: 81,
222
					Protocol:      "tcp",
223
				},
224
			},
225
			want: []types.PortMapping{
226
				{
227
					HostPort:      8080,
228
					ContainerPort: 80,
229
					Protocol:      "tcp",
230
					Range:         2,
231
				},
232
			},
233
		},
234
		{
235
			name: "two ports with no overlapping range",
236
			arg: []types.PortMapping{
237
				{
238
					HostPort:      8080,
239
					ContainerPort: 80,
240
					Protocol:      "tcp",
241
					Range:         10,
242
				},
243
				{
244
					HostPort:      9090,
245
					ContainerPort: 9090,
246
					Protocol:      "tcp",
247
				},
248
			},
249
			want: []types.PortMapping{
250
				{
251
					HostPort:      9090,
252
					ContainerPort: 9090,
253
					Protocol:      "tcp",
254
					Range:         1,
255
				},
256
				{
257
					HostPort:      8080,
258
					ContainerPort: 80,
259
					Protocol:      "tcp",
260
					Range:         10,
261
				},
262
			},
263
		},
264
		{
265
			name: "four ports with two overlapping ranges",
266
			arg: []types.PortMapping{
267
				{
268
					HostPort:      8080,
269
					ContainerPort: 80,
270
					Protocol:      "tcp",
271
					Range:         10,
272
				},
273
				{
274
					HostPort:      8085,
275
					ContainerPort: 85,
276
					Protocol:      "tcp",
277
					Range:         10,
278
				},
279
				{
280
					HostPort:      100,
281
					ContainerPort: 5,
282
					Protocol:      "tcp",
283
				},
284
				{
285
					HostPort:      101,
286
					ContainerPort: 6,
287
					Protocol:      "tcp",
288
				},
289
			},
290
			want: []types.PortMapping{
291
				{
292
					HostPort:      8080,
293
					ContainerPort: 80,
294
					Protocol:      "tcp",
295
					Range:         15,
296
				},
297
				{
298
					HostPort:      100,
299
					ContainerPort: 5,
300
					Protocol:      "tcp",
301
					Range:         2,
302
				},
303
			},
304
		},
305
		{
306
			name: "two overlapping ranges",
307
			arg: []types.PortMapping{
308
				{
309
					HostPort:      8080,
310
					ContainerPort: 80,
311
					Protocol:      "tcp",
312
					Range:         10,
313
				},
314
				{
315
					HostPort:      8085,
316
					ContainerPort: 85,
317
					Protocol:      "tcp",
318
					Range:         2,
319
				},
320
			},
321
			want: []types.PortMapping{
322
				{
323
					HostPort:      8080,
324
					ContainerPort: 80,
325
					Protocol:      "tcp",
326
					Range:         10,
327
				},
328
			},
329
		},
330
		{
331
			name: "four overlapping ranges",
332
			arg: []types.PortMapping{
333
				{
334
					HostPort:      8080,
335
					ContainerPort: 80,
336
					Protocol:      "tcp",
337
					Range:         10,
338
				},
339
				{
340
					HostPort:      8085,
341
					ContainerPort: 85,
342
					Protocol:      "tcp",
343
					Range:         2,
344
				},
345
				{
346
					HostPort:      8090,
347
					ContainerPort: 90,
348
					Protocol:      "tcp",
349
					Range:         7,
350
				},
351
				{
352
					HostPort:      8095,
353
					ContainerPort: 95,
354
					Protocol:      "tcp",
355
				},
356
			},
357
			want: []types.PortMapping{
358
				{
359
					HostPort:      8080,
360
					ContainerPort: 80,
361
					Protocol:      "tcp",
362
					Range:         17,
363
				},
364
			},
365
		},
366
		{
367
			name: "one port range overlaps 5 ports",
368
			arg: []types.PortMapping{
369
				{
370
					HostPort:      8080,
371
					ContainerPort: 80,
372
					Range:         20,
373
				},
374
				{
375
					HostPort:      8085,
376
					ContainerPort: 85,
377
					Range:         2,
378
				},
379
				{
380
					HostPort:      8090,
381
					ContainerPort: 90,
382
				},
383
				{
384
					HostPort:      8095,
385
					ContainerPort: 95,
386
				},
387
				{
388
					HostPort:      8096,
389
					ContainerPort: 96,
390
				},
391
			},
392
			want: []types.PortMapping{
393
				{
394
					HostPort:      8080,
395
					ContainerPort: 80,
396
					Protocol:      "tcp",
397
					Range:         20,
398
				},
399
			},
400
		},
401
		{
402
			name: "different host ip same port",
403
			arg: []types.PortMapping{
404
				{
405
					HostPort:      8080,
406
					ContainerPort: 80,
407
					Protocol:      "tcp",
408
					HostIP:        "192.168.1.1",
409
				},
410
				{
411
					HostPort:      8080,
412
					ContainerPort: 80,
413
					Protocol:      "tcp",
414
					HostIP:        "192.168.2.1",
415
				},
416
			},
417
			want: []types.PortMapping{
418
				{
419
					HostPort:      8080,
420
					ContainerPort: 80,
421
					Protocol:      "tcp",
422
					HostIP:        "192.168.1.1",
423
					Range:         1,
424
				},
425
				{
426
					HostPort:      8080,
427
					ContainerPort: 80,
428
					Protocol:      "tcp",
429
					HostIP:        "192.168.2.1",
430
					Range:         1,
431
				},
432
			},
433
		},
434
	}
435
	for _, tt := range tests {
436
		tt := tt
437
		t.Run(tt.name, func(t *testing.T) {
438
			got, err := ParsePortMapping(tt.arg, tt.arg2)
439
			assert.NoError(t, err, "error is not nil")
440
			// use ElementsMatch instead of Equal because the order is not consistent
441
			assert.ElementsMatch(t, tt.want, got, "got unexpected port mapping")
442
		})
443
	}
444
}
445

446
func TestParsePortMappingWithoutHostPort(t *testing.T) {
447
	tests := []struct {
448
		name string
449
		arg  []types.PortMapping
450
		arg2 map[uint16][]string
451
		want []types.PortMapping
452
	}{
453
		{
454
			name: "one tcp port",
455
			arg: []types.PortMapping{
456
				{
457
					HostPort:      0,
458
					ContainerPort: 80,
459
					Protocol:      "tcp",
460
				},
461
			},
462
			want: []types.PortMapping{
463
				{
464
					HostPort:      0,
465
					ContainerPort: 80,
466
					Protocol:      "tcp",
467
					Range:         1,
468
				},
469
			},
470
		},
471
		{
472
			name: "one port with two protocols",
473
			arg: []types.PortMapping{
474
				{
475
					HostPort:      0,
476
					ContainerPort: 80,
477
					Protocol:      "tcp,udp",
478
				},
479
			},
480
			want: []types.PortMapping{
481
				{
482
					HostPort:      0,
483
					ContainerPort: 80,
484
					Protocol:      "tcp",
485
					Range:         1,
486
				},
487
				{
488
					HostPort:      0,
489
					ContainerPort: 80,
490
					Protocol:      "udp",
491
					Range:         1,
492
				},
493
			},
494
		},
495
		{
496
			name: "same port twice",
497
			arg: []types.PortMapping{
498
				{
499
					HostPort:      0,
500
					ContainerPort: 80,
501
					Protocol:      "tcp",
502
				},
503
				{
504
					HostPort:      0,
505
					ContainerPort: 80,
506
					Protocol:      "tcp",
507
				},
508
			},
509
			want: []types.PortMapping{
510
				{
511
					HostPort:      0,
512
					ContainerPort: 80,
513
					Protocol:      "tcp",
514
					Range:         1,
515
				},
516
			},
517
		},
518
		{
519
			name: "neighbor ports are not joined",
520
			arg: []types.PortMapping{
521
				{
522
					HostPort:      0,
523
					ContainerPort: 80,
524
					Protocol:      "tcp",
525
				},
526
				{
527
					HostPort:      0,
528
					ContainerPort: 81,
529
					Protocol:      "tcp",
530
				},
531
			},
532
			want: []types.PortMapping{
533
				{
534
					HostPort:      0,
535
					ContainerPort: 80,
536
					Protocol:      "tcp",
537
					Range:         1,
538
				},
539
				{
540
					HostPort:      0,
541
					ContainerPort: 81,
542
					Protocol:      "tcp",
543
					Range:         1,
544
				},
545
			},
546
		},
547
		{
548
			name: "overlapping range ports are joined",
549
			arg: []types.PortMapping{
550
				{
551
					HostPort:      0,
552
					ContainerPort: 80,
553
					Protocol:      "tcp",
554
					Range:         2,
555
				},
556
				{
557
					HostPort:      0,
558
					ContainerPort: 81,
559
					Protocol:      "tcp",
560
				},
561
			},
562
			want: []types.PortMapping{
563
				{
564
					HostPort:      0,
565
					ContainerPort: 80,
566
					Protocol:      "tcp",
567
					Range:         2,
568
				},
569
			},
570
		},
571
		{
572
			name: "four overlapping range ports are joined",
573
			arg: []types.PortMapping{
574
				{
575
					HostPort:      0,
576
					ContainerPort: 80,
577
					Protocol:      "tcp",
578
					Range:         3,
579
				},
580
				{
581
					HostPort:      0,
582
					ContainerPort: 81,
583
					Protocol:      "tcp",
584
				},
585
				{
586
					HostPort:      0,
587
					ContainerPort: 82,
588
					Protocol:      "tcp",
589
					Range:         10,
590
				},
591
				{
592
					HostPort:      0,
593
					ContainerPort: 90,
594
					Protocol:      "tcp",
595
					Range:         5,
596
				},
597
			},
598
			want: []types.PortMapping{
599
				{
600
					HostPort:      0,
601
					ContainerPort: 80,
602
					Protocol:      "tcp",
603
					Range:         15,
604
				},
605
			},
606
		},
607
		{
608
			name: "expose one tcp port",
609
			arg2: map[uint16][]string{
610
				8080: {"tcp"},
611
			},
612
			want: []types.PortMapping{
613
				{
614
					HostPort:      0,
615
					ContainerPort: 8080,
616
					Protocol:      "tcp",
617
					Range:         1,
618
				},
619
			},
620
		},
621
		{
622
			name: "expose already defined port",
623
			arg: []types.PortMapping{
624
				{
625
					HostPort:      0,
626
					ContainerPort: 8080,
627
					Protocol:      "tcp",
628
				},
629
			},
630
			arg2: map[uint16][]string{
631
				8080: {"tcp"},
632
			},
633
			want: []types.PortMapping{
634
				{
635
					HostPort:      0,
636
					ContainerPort: 8080,
637
					Protocol:      "tcp",
638
					Range:         1,
639
				},
640
			},
641
		},
642
		{
643
			name: "expose different proto",
644
			arg: []types.PortMapping{
645
				{
646
					HostPort:      0,
647
					ContainerPort: 8080,
648
					Protocol:      "tcp",
649
				},
650
			},
651
			arg2: map[uint16][]string{
652
				8080: {"udp"},
653
			},
654
			want: []types.PortMapping{
655
				{
656
					HostPort:      0,
657
					ContainerPort: 8080,
658
					Protocol:      "tcp",
659
					Range:         1,
660
				},
661
				{
662
					HostPort:      0,
663
					ContainerPort: 8080,
664
					Protocol:      "udp",
665
					Range:         1,
666
				},
667
			},
668
		},
669
	}
670
	for _, tt := range tests {
671
		tt := tt
672
		t.Run(tt.name, func(t *testing.T) {
673
			got, err := ParsePortMapping(tt.arg, tt.arg2)
674
			assert.NoError(t, err, "error is not nil")
675

676
			// because we always get random host ports when it is set to 0 we cannot check that exactly
677
			// check if it is not 0 and set to 0 afterwards
678
			for i := range got {
679
				assert.Greater(t, got[i].HostPort, uint16(0), "host port is zero")
680
				got[i].HostPort = 0
681
			}
682

683
			// use ElementsMatch instead of Equal because the order is not consistent
684
			assert.ElementsMatch(t, tt.want, got, "got unexpected port mapping")
685
		})
686
	}
687
}
688

689
func TestParsePortMappingMixedHostPort(t *testing.T) {
690
	tests := []struct {
691
		name           string
692
		arg            []types.PortMapping
693
		want           []types.PortMapping
694
		resetHostPorts []int
695
	}{
696
		{
697
			name: "two ports one without a hostport set",
698
			arg: []types.PortMapping{
699
				{
700
					HostPort:      0,
701
					ContainerPort: 80,
702
				},
703
				{
704
					HostPort:      8080,
705
					ContainerPort: 8080,
706
				},
707
			},
708
			want: []types.PortMapping{
709
				{
710
					HostPort:      8080,
711
					ContainerPort: 8080,
712
					Protocol:      "tcp",
713
					Range:         1,
714
				},
715
				{
716
					HostPort:      0,
717
					ContainerPort: 80,
718
					Protocol:      "tcp",
719
					Range:         1,
720
				},
721
			},
722
			resetHostPorts: []int{1},
723
		},
724
		{
725
			name: "two ports one without a hostport set, inverted order",
726
			arg: []types.PortMapping{
727
				{
728
					HostPort:      8080,
729
					ContainerPort: 8080,
730
				},
731
				{
732
					HostPort:      0,
733
					ContainerPort: 80,
734
				},
735
			},
736
			want: []types.PortMapping{
737
				{
738
					HostPort:      8080,
739
					ContainerPort: 8080,
740
					Protocol:      "tcp",
741
					Range:         1,
742
				},
743
				{
744
					HostPort:      0,
745
					ContainerPort: 80,
746
					Protocol:      "tcp",
747
					Range:         1,
748
				},
749
			},
750
			resetHostPorts: []int{1},
751
		},
752
		{
753
			name: "three ports without host ports, one with a hostport set, , inverted order",
754
			arg: []types.PortMapping{
755
				{
756
					HostPort:      0,
757
					ContainerPort: 80,
758
				},
759
				{
760
					HostPort:      0,
761
					ContainerPort: 85,
762
				},
763
				{
764
					HostPort:      0,
765
					ContainerPort: 90,
766
				},
767
				{
768
					HostPort:      8080,
769
					ContainerPort: 8080,
770
				},
771
			},
772
			want: []types.PortMapping{
773
				{
774
					HostPort:      8080,
775
					ContainerPort: 8080,
776
					Protocol:      "tcp",
777
					Range:         1,
778
				},
779
				{
780
					HostPort:      0,
781
					ContainerPort: 80,
782
					Protocol:      "tcp",
783
					Range:         1,
784
				},
785
				{
786
					HostPort:      0,
787
					ContainerPort: 85,
788
					Protocol:      "tcp",
789
					Range:         1,
790
				},
791
				{
792
					HostPort:      0,
793
					ContainerPort: 90,
794
					Protocol:      "tcp",
795
					Range:         1,
796
				},
797
			},
798
			resetHostPorts: []int{1, 2, 3},
799
		},
800
		{
801
			name: "three ports without host ports, one with a hostport set",
802
			arg: []types.PortMapping{
803
				{
804
					HostPort:      8080,
805
					ContainerPort: 8080,
806
				},
807
				{
808
					HostPort:      0,
809
					ContainerPort: 90,
810
				},
811
				{
812
					HostPort:      0,
813
					ContainerPort: 85,
814
				},
815
				{
816
					HostPort:      0,
817
					ContainerPort: 80,
818
				},
819
			},
820
			want: []types.PortMapping{
821
				{
822
					HostPort:      8080,
823
					ContainerPort: 8080,
824
					Protocol:      "tcp",
825
					Range:         1,
826
				},
827
				{
828
					HostPort:      0,
829
					ContainerPort: 80,
830
					Protocol:      "tcp",
831
					Range:         1,
832
				},
833
				{
834
					HostPort:      0,
835
					ContainerPort: 85,
836
					Protocol:      "tcp",
837
					Range:         1,
838
				},
839
				{
840
					HostPort:      0,
841
					ContainerPort: 90,
842
					Protocol:      "tcp",
843
					Range:         1,
844
				},
845
			},
846
			resetHostPorts: []int{1, 2, 3},
847
		},
848
	}
849
	for _, tt := range tests {
850
		tt := tt
851
		t.Run(tt.name, func(t *testing.T) {
852
			got, err := ParsePortMapping(tt.arg, nil)
853
			assert.NoError(t, err, "error is not nil")
854

855
			// because we always get random host ports when it is set to 0 we cannot check that exactly
856
			// use resetHostPorts to know which port element is 0
857
			for _, num := range tt.resetHostPorts {
858
				assert.Greater(t, got[num].HostPort, uint16(0), "host port is zero")
859
				got[num].HostPort = 0
860
			}
861

862
			assert.Equal(t, tt.want, got, "got unexpected port mapping")
863
		})
864
	}
865
}
866

867
func TestParsePortMappingError(t *testing.T) {
868
	tests := []struct {
869
		name string
870
		arg  []types.PortMapping
871
		err  string
872
	}{
873
		{
874
			name: "container port is 0",
875
			arg: []types.PortMapping{
876
				{
877
					HostPort:      8080,
878
					ContainerPort: 0,
879
					Protocol:      "tcp",
880
				},
881
			},
882
			err: "container port number must be non-0",
883
		},
884
		{
885
			name: "container port range exceeds max",
886
			arg: []types.PortMapping{
887
				{
888
					HostPort:      8080,
889
					ContainerPort: 65000,
890
					Protocol:      "tcp",
891
					Range:         10000,
892
				},
893
			},
894
			err: "container port range exceeds maximum allowable port number",
895
		},
896
		{
897
			name: "host port range exceeds max",
898
			arg: []types.PortMapping{
899
				{
900
					HostPort:      60000,
901
					ContainerPort: 1,
902
					Protocol:      "tcp",
903
					Range:         10000,
904
				},
905
			},
906
			err: "host port range exceeds maximum allowable port number",
907
		},
908
		{
909
			name: "invalid protocol",
910
			arg: []types.PortMapping{
911
				{
912
					HostPort:      8080,
913
					ContainerPort: 80,
914
					Protocol:      "1",
915
				},
916
			},
917
			err: "unrecognized protocol \"1\" in port mapping",
918
		},
919
		{
920
			name: "invalid protocol 2",
921
			arg: []types.PortMapping{
922
				{
923
					HostPort:      8080,
924
					ContainerPort: 80,
925
					Protocol:      "udp,u",
926
				},
927
			},
928
			err: "unrecognized protocol \"u\" in port mapping",
929
		},
930
		{
931
			name: "invalid ip address",
932
			arg: []types.PortMapping{
933
				{
934
					HostPort:      8080,
935
					ContainerPort: 80,
936
					HostIP:        "blah",
937
				},
938
			},
939
			err: "invalid IP address \"blah\" in port mapping",
940
		},
941
		{
942
			name: "invalid overalpping range",
943
			arg: []types.PortMapping{
944
				{
945
					HostPort:      8080,
946
					ContainerPort: 80,
947
					Range:         5,
948
				},
949
				{
950
					HostPort:      8081,
951
					ContainerPort: 60,
952
				},
953
			},
954
			err: "conflicting port mappings for host port 8081 (protocol tcp)",
955
		},
956
		{
957
			name: "big port range with host port zero does not fit",
958
			arg: []types.PortMapping{
959
				{
960
					HostPort:      0,
961
					ContainerPort: 1,
962
					Range:         65535,
963
				},
964
			},
965
			err: "failed to find an open port to expose container port 1 with range 65535 on the host",
966
		},
967
		{
968
			name: "big port range with host port zero does not fit",
969
			arg: []types.PortMapping{
970
				{
971
					HostPort:      0,
972
					ContainerPort: 80,
973
					Range:         1,
974
				},
975
				{
976
					HostPort:      0,
977
					ContainerPort: 1000,
978
					Range:         64535,
979
				},
980
			},
981
			err: "failed to find an open port to expose container port 1000 with range 64535 on the host",
982
		},
983
	}
984
	for _, tt := range tests {
985
		tt := tt
986
		t.Run(tt.name, func(t *testing.T) {
987
			_, err := ParsePortMapping(tt.arg, nil)
988
			assert.EqualError(t, err, tt.err, "error does not match")
989
		})
990
	}
991
}
992