podman

namespaces_test.go
256 строк · 7.0 Кб
Перенос по словам
1
package specgen
2

3
import (
4
	"net"
5
	"testing"
6

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

11
func parsMacNoErr(mac string) types.HardwareAddr {
12
	m, _ := net.ParseMAC(mac)
13
	return types.HardwareAddr(m)
14
}
15

16
func TestParseNetworkFlag(t *testing.T) {
17
	// root and rootless have different defaults
18
	defaultNetName := "default"
19

20
	tests := []struct {
21
		name     string
22
		args     []string
23
		nsmode   Namespace
24
		networks map[string]types.PerNetworkOptions
25
		options  map[string][]string
26
		err      string
27
	}{
28
		{
29
			name:     "empty input",
30
			args:     nil,
31
			nsmode:   Namespace{NSMode: Private},
32
			networks: map[string]types.PerNetworkOptions{},
33
		},
34
		{
35
			name:     "empty string as input",
36
			args:     []string{},
37
			nsmode:   Namespace{NSMode: Private},
38
			networks: map[string]types.PerNetworkOptions{},
39
		},
40
		{
41
			name:     "default mode",
42
			args:     []string{"default"},
43
			nsmode:   Namespace{NSMode: Private},
44
			networks: map[string]types.PerNetworkOptions{},
45
		},
46
		{
47
			name:     "private mode",
48
			args:     []string{"private"},
49
			nsmode:   Namespace{NSMode: Private},
50
			networks: map[string]types.PerNetworkOptions{},
51
		},
52
		{
53
			name:   "bridge mode",
54
			args:   []string{"bridge"},
55
			nsmode: Namespace{NSMode: Bridge},
56
			networks: map[string]types.PerNetworkOptions{
57
				defaultNetName: {},
58
			},
59
		},
60
		{
61
			name:     "slirp4netns mode",
62
			args:     []string{"slirp4netns"},
63
			nsmode:   Namespace{NSMode: Slirp},
64
			networks: map[string]types.PerNetworkOptions{},
65
		},
66
		{
67
			name:     "from pod mode",
68
			args:     []string{"pod"},
69
			nsmode:   Namespace{NSMode: FromPod},
70
			networks: map[string]types.PerNetworkOptions{},
71
		},
72
		{
73
			name:     "no network mode",
74
			args:     []string{"none"},
75
			nsmode:   Namespace{NSMode: NoNetwork},
76
			networks: map[string]types.PerNetworkOptions{},
77
		},
78
		{
79
			name:     "container mode",
80
			args:     []string{"container:abc"},
81
			nsmode:   Namespace{NSMode: FromContainer, Value: "abc"},
82
			networks: map[string]types.PerNetworkOptions{},
83
		},
84
		{
85
			name:     "ns path mode",
86
			args:     []string{"ns:/path"},
87
			nsmode:   Namespace{NSMode: Path, Value: "/path"},
88
			networks: map[string]types.PerNetworkOptions{},
89
		},
90
		{
91
			name:     "slirp4netns mode with options",
92
			args:     []string{"slirp4netns:cidr=10.0.0.0/24"},
93
			nsmode:   Namespace{NSMode: Slirp},
94
			networks: map[string]types.PerNetworkOptions{},
95
			options: map[string][]string{
96
				"slirp4netns": {"cidr=10.0.0.0/24"},
97
			},
98
		},
99
		{
100
			name:   "bridge mode with options 1",
101
			args:   []string{"bridge:ip=10.0.0.1,mac=11:22:33:44:55:66"},
102
			nsmode: Namespace{NSMode: Bridge},
103
			networks: map[string]types.PerNetworkOptions{
104
				defaultNetName: {
105
					StaticIPs: []net.IP{net.ParseIP("10.0.0.1")},
106
					StaticMAC: parsMacNoErr("11:22:33:44:55:66"),
107
				},
108
			},
109
		},
110
		{
111
			name:   "bridge mode with options 2",
112
			args:   []string{"bridge:ip=10.0.0.1,ip=10.0.0.5"},
113
			nsmode: Namespace{NSMode: Bridge},
114
			networks: map[string]types.PerNetworkOptions{
115
				defaultNetName: {
116
					StaticIPs: []net.IP{net.ParseIP("10.0.0.1"), net.ParseIP("10.0.0.5")},
117
				},
118
			},
119
		},
120
		{
121
			name:   "bridge mode with ip6 option",
122
			args:   []string{"bridge:ip6=fd10::"},
123
			nsmode: Namespace{NSMode: Bridge},
124
			networks: map[string]types.PerNetworkOptions{
125
				defaultNetName: {
126
					StaticIPs: []net.IP{net.ParseIP("fd10::")},
127
				},
128
			},
129
		},
130
		{
131
			name:   "bridge mode with alias option",
132
			args:   []string{"bridge:alias=myname,alias=myname2"},
133
			nsmode: Namespace{NSMode: Bridge},
134
			networks: map[string]types.PerNetworkOptions{
135
				defaultNetName: {
136
					Aliases: []string{"myname", "myname2"},
137
				},
138
			},
139
		},
140
		{
141
			name:   "bridge mode with alias option",
142
			args:   []string{"bridge:alias=myname,alias=myname2"},
143
			nsmode: Namespace{NSMode: Bridge},
144
			networks: map[string]types.PerNetworkOptions{
145
				defaultNetName: {
146
					Aliases: []string{"myname", "myname2"},
147
				},
148
			},
149
		},
150
		{
151
			name:   "bridge mode with interface option",
152
			args:   []string{"bridge:interface_name=eth123"},
153
			nsmode: Namespace{NSMode: Bridge},
154
			networks: map[string]types.PerNetworkOptions{
155
				defaultNetName: {
156
					InterfaceName: "eth123",
157
				},
158
			},
159
		},
160
		{
161
			name:   "bridge mode with invalid option",
162
			args:   []string{"bridge:abc=123"},
163
			nsmode: Namespace{NSMode: Bridge},
164
			err:    "unknown bridge network option: abc",
165
		},
166
		{
167
			name:   "bridge mode with invalid ip",
168
			args:   []string{"bridge:ip=10..1"},
169
			nsmode: Namespace{NSMode: Bridge},
170
			err:    "invalid ip address \"10..1\"",
171
		},
172
		{
173
			name:   "bridge mode with invalid mac",
174
			args:   []string{"bridge:mac=123"},
175
			nsmode: Namespace{NSMode: Bridge},
176
			err:    "address 123: invalid MAC address",
177
		},
178
		{
179
			name:   "network name",
180
			args:   []string{"someName"},
181
			nsmode: Namespace{NSMode: Bridge},
182
			networks: map[string]types.PerNetworkOptions{
183
				"someName": {},
184
			},
185
		},
186
		{
187
			name:   "network name with options",
188
			args:   []string{"someName:ip=10.0.0.1"},
189
			nsmode: Namespace{NSMode: Bridge},
190
			networks: map[string]types.PerNetworkOptions{
191
				"someName": {StaticIPs: []net.IP{net.ParseIP("10.0.0.1")}},
192
			},
193
		},
194
		{
195
			name:   "multiple networks",
196
			args:   []string{"someName", "net2"},
197
			nsmode: Namespace{NSMode: Bridge},
198
			networks: map[string]types.PerNetworkOptions{
199
				"someName": {},
200
				"net2":     {},
201
			},
202
		},
203
		{
204
			name:   "multiple networks with options",
205
			args:   []string{"someName:ip=10.0.0.1", "net2:ip=10.10.0.1"},
206
			nsmode: Namespace{NSMode: Bridge},
207
			networks: map[string]types.PerNetworkOptions{
208
				"someName": {StaticIPs: []net.IP{net.ParseIP("10.0.0.1")}},
209
				"net2":     {StaticIPs: []net.IP{net.ParseIP("10.10.0.1")}},
210
			},
211
		},
212
		{
213
			name:   "multiple networks with bridge mode first should map to default net",
214
			args:   []string{"bridge", "net2"},
215
			nsmode: Namespace{NSMode: Bridge},
216
			networks: map[string]types.PerNetworkOptions{
217
				defaultNetName: {},
218
				"net2":         {},
219
			},
220
		},
221
		{
222
			name:   "conflicting network modes should error",
223
			args:   []string{"bridge", "host"},
224
			nsmode: Namespace{NSMode: Bridge},
225
			err:    "can only set extra network names, selected mode host conflicts with bridge: invalid argument",
226
		},
227
		{
228
			name:   "multiple networks empty name should error",
229
			args:   []string{"someName", ""},
230
			nsmode: Namespace{NSMode: Bridge},
231
			err:    "network name cannot be empty: invalid argument",
232
		},
233
		{
234
			name:   "multiple networks on invalid mode should error",
235
			args:   []string{"host", "net2"},
236
			nsmode: Namespace{NSMode: Host},
237
			err:    "cannot set multiple networks without bridge network mode, selected mode host: invalid argument",
238
		},
239
	}
240

241
	for _, tt := range tests {
242
		tt := tt
243
		t.Run(tt.name, func(t *testing.T) {
244
			got, got1, got2, err := ParseNetworkFlag(tt.args)
245
			if tt.err != "" {
246
				assert.EqualError(t, err, tt.err, tt.name)
247
			} else {
248
				assert.NoError(t, err, tt.name)
249
			}
250

251
			assert.Equal(t, tt.nsmode, got, tt.name)
252
			assert.Equal(t, tt.networks, got1, tt.name)
253
			assert.Equal(t, tt.options, got2, tt.name)
254
		})
255
	}
256
}
257
podman

Использование cookies
