podman

1
package specgenutil
2

3
import (
4
	"reflect"
5
	"testing"
6
)
7

8
func TestCreateExpose(t *testing.T) {
9
	single := make(map[uint16]string, 0)
10
	single[99] = "tcp"
11

12
	simpleRange := make(map[uint16]string, 0)
13
	simpleRange[99] = "tcp"
14
	simpleRange[100] = "tcp"
15

16
	simpleRangeUDP := make(map[uint16]string, 0)
17
	simpleRangeUDP[99] = "udp"
18
	simpleRangeUDP[100] = "udp"
19
	type args struct {
20
		expose []string
21
	}
22
	tests := []struct {
23
		name    string
24
		args    args
25
		want    map[uint16]string
26
		wantErr bool
27
	}{
28
		{
29
			name: "single port",
30
			args: args{
31
				expose: []string{"99"},
32
			},
33
			want:    single,
34
			wantErr: false,
35
		},
36
		{
37
			name: "simple range tcp",
38
			args: args{
39
				expose: []string{"99-100"},
40
			},
41
			want:    simpleRange,
42
			wantErr: false,
43
		},
44
		{
45
			name: "simple range udp",
46
			args: args{
47
				expose: []string{"99-100/udp"},
48
			},
49
			want:    simpleRangeUDP,
50
			wantErr: false,
51
		},
52
		{
53
			name: "range inverted should fail",
54
			args: args{
55
				expose: []string{"100-99"},
56
			},
57
			want:    nil,
58
			wantErr: true,
59
		},
60
		{
61
			name: "specifying protocol twice should fail",
62
			args: args{
63
				expose: []string{"99/tcp-100/tcp"},
64
			},
65
			want:    nil,
66
			wantErr: true,
67
		},
68
	}
69
	for _, tt := range tests {
70
		t.Run(tt.name, func(t *testing.T) {
71
			got, err := CreateExpose(tt.args.expose)
72
			if (err != nil) != tt.wantErr {
73
				t.Errorf("CreateExpose() error = %v, wantErr %v", err, tt.wantErr)
74
				return
75
			}
76
			if !reflect.DeepEqual(got, tt.want) {
77
				t.Errorf("CreateExpose() got = %v, want %v", got, tt.want)
78
			}
79
		})
80
	}
81
}
82

83
func Test_parseAndValidatePort(t *testing.T) {
84
	type args struct {
85
		port string
86
	}
87
	tests := []struct {
88
		name    string
89
		args    args
90
		want    uint16
91
		wantErr bool
92
	}{
93
		{
94
			name: "0 should fail",
95
			args: args{
96
				port: "0",
97
			},
98
			want:    0,
99
			wantErr: true,
100
		},
101
		{
102
			name: "over 65535 should fail",
103
			args: args{
104
				port: "66666",
105
			},
106
			want:    0,
107
			wantErr: true,
108
		},
109
		{
110
			name: "",
111
			args: args{
112
				port: "99",
113
			},
114
			want:    99,
115
			wantErr: false,
116
		},
117
		{
118
			name: "negative values should fail",
119
			args: args{
120
				port: "-1",
121
			},
122
			want:    0,
123
			wantErr: true,
124
		},
125
		{
126
			name: "protocol should fail",
127
			args: args{
128
				port: "99/tcp",
129
			},
130
			want:    0,
131
			wantErr: true,
132
		},
133
	}
134
	for _, tt := range tests {
135
		t.Run(tt.name, func(t *testing.T) {
136
			got, err := parseAndValidatePort(tt.args.port)
137
			if (err != nil) != tt.wantErr {
138
				t.Errorf("parseAndValidatePort() error = %v, wantErr %v", err, tt.wantErr)
139
				return
140
			}
141
			if got != tt.want {
142
				t.Errorf("parseAndValidatePort() got = %v, want %v", got, tt.want)
143
			}
144
		})
145
	}
146
}
147